{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/huangzhiming/Documents/math_readproof_work-_ipython_files/2024'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load \"environment.py\"\n",
    "# You must import sympy.abc first then import sympy\n",
    "# or it will have some bugs when it run solvers for \n",
    "# trigeometric functions.\n",
    "from sympy.abc import x,y,z,t,k,l,n,m,p,q\n",
    "from sympy import *\n",
    "from sympy.calculus.util import *\n",
    "from sympy.stats import *\n",
    "\n",
    "from sys import path,platform\n",
    "match platform:\n",
    "    case \"linux\":\n",
    "        path.append(\"/home/huang/Documents/packaging_tutorial/src\")\n",
    "    case \"darwin\":\n",
    "        path.append(\"/Users/huangzhiming/Documents/python学习/packaging_tutorial/src\")\n",
    "%load_ext autoreload \n",
    "%autoreload 1\n",
    "\n",
    "%aimport basic_package.utils\n",
    "%aimport function_calculator_package.extreme_points\n",
    "%aimport function_calculator_package.utils\n",
    "%aimport quadratic_function.utils\n",
    "%aimport quadratic_function.hyperbola\n",
    "%aimport quadratic_function.utils\n",
    "\n",
    "from basic_package.utils import *\n",
    "from function_calculator_package.extreme_points import *\n",
    "from function_calculator_package.utils import *\n",
    "from quadratic_function.quadraticfunction import QuadraticFunction\n",
    "from quadratic_function.hyperbola import Hyperbola\n",
    "from quadratic_function.utils import line_and_quadratic\n",
    "\n",
    "%aimport excel_function_package.chi_square_test\n",
    "from excel_function_package.chi_square_test import ChiSquaredTest,chi_squared_of_error_probability\n",
    "%aimport excel_function_package.data\n",
    "\n",
    "from excel_function_package.data import Data\n",
    "\n",
    "%aimport solver.utils\n",
    "from solver.utils import solve_univariate_inequalities\n",
    "\n",
    "%aimport function_calculator_package.utils \n",
    "from function_calculator_package.utils import function_is_odd,function_is_even\n",
    "\n",
    "%aimport geometry3D.frustum\n",
    "%aimport geometry3D.prism\n",
    "%aimport geometry3D.pyramid\n",
    "%aimport geometry3D.frustum_cone\n",
    "%aimport geometry3D.sphere\n",
    "\n",
    "from geometry3D.frustum import Frustum\n",
    "from geometry3D.prism import Prism,Cube\n",
    "from geometry3D.pyramid import Pyramid,Cone,Tetrahedron\n",
    "from geometry3D.frustum_cone import FrustumCone\n",
    "from geometry3D.sphere import Sphere\n",
    "a,b,c=symbols(\"a,b,c\",real=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=1/((x-1)*sin(2*x-3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function singularities in module sympy.calculus.singularities:\n",
      "\n",
      "singularities(expression, symbol, domain=None)\n",
      "    Find singularities of a given function.\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    expression : Expr\n",
      "        The target function in which singularities need to be found.\n",
      "    symbol : Symbol\n",
      "        The symbol over the values of which the singularity in\n",
      "        expression in being searched for.\n",
      "    \n",
      "    Returns\n",
      "    =======\n",
      "    \n",
      "    Set\n",
      "        A set of values for ``symbol`` for which ``expression`` has a\n",
      "        singularity. An ``EmptySet`` is returned if ``expression`` has no\n",
      "        singularities for any given value of ``Symbol``.\n",
      "    \n",
      "    Raises\n",
      "    ======\n",
      "    \n",
      "    NotImplementedError\n",
      "        Methods for determining the singularities of this function have\n",
      "        not been developed.\n",
      "    \n",
      "    Notes\n",
      "    =====\n",
      "    \n",
      "    This function does not find non-isolated singularities\n",
      "    nor does it find branch points of the expression.\n",
      "    \n",
      "    Currently supported functions are:\n",
      "        - univariate continuous (real or complex) functions\n",
      "    \n",
      "    References\n",
      "    ==========\n",
      "    \n",
      "    .. [1] https://en.wikipedia.org/wiki/Mathematical_singularity\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy import singularities, Symbol, log\n",
      "    >>> x = Symbol('x', real=True)\n",
      "    >>> y = Symbol('y', real=False)\n",
      "    >>> singularities(x**2 + x + 1, x)\n",
      "    EmptySet\n",
      "    >>> singularities(1/(x + 1), x)\n",
      "    {-1}\n",
      "    >>> singularities(1/(y**2 + 1), y)\n",
      "    {-I, I}\n",
      "    >>> singularities(1/(y**3 + 1), y)\n",
      "    {-1, 1/2 - sqrt(3)*I/2, 1/2 + sqrt(3)*I/2}\n",
      "    >>> singularities(log(x), x)\n",
      "    {0}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(singularities)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{1\\right\\} \\cup \\left\\{- \\frac{i \\left(i \\left(2 n \\pi + \\operatorname{atan}{\\left(\\frac{\\sin{\\left(3 \\right)}}{\\cos{\\left(3 \\right)}} \\right)}\\right) + \\log{\\left(\\sqrt{\\sin^{2}{\\left(3 \\right)} + \\cos^{2}{\\left(3 \\right)}} \\right)}\\right)}{2}\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\} \\cup \\left\\{- \\frac{i \\left(i \\left(2 n \\pi + \\operatorname{atan}{\\left(\\frac{\\sin{\\left(3 \\right)}}{\\cos{\\left(3 \\right)}} \\right)} + \\pi\\right) + \\log{\\left(\\sqrt{\\sin^{2}{\\left(3 \\right)} + \\cos^{2}{\\left(3 \\right)}} \\right)}\\right)}{2}\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\}$"
      ],
      "text/plain": [
       "Union({1}, ImageSet(Lambda(_n, -I*(I*(2*_n*pi + atan(sin(3)/cos(3)) + pi) + log(sqrt(sin(3)**2 + cos(3)**2)))/2), Integers), ImageSet(Lambda(_n, -I*(I*(2*_n*pi + atan(sin(3)/cos(3))) + log(sqrt(sin(3)**2 + cos(3)**2)))/2), Integers))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "singularities(expr,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{1\\right\\} \\cup \\left\\{- \\frac{i \\left(i \\left(2 n \\pi + \\operatorname{atan}{\\left(\\frac{\\sin{\\left(3 \\right)}}{\\cos{\\left(3 \\right)}} \\right)}\\right) + \\log{\\left(\\sqrt{\\sin^{2}{\\left(3 \\right)} + \\cos^{2}{\\left(3 \\right)}} \\right)}\\right)}{2}\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\} \\cup \\left\\{- \\frac{i \\left(i \\left(2 n \\pi + \\operatorname{atan}{\\left(\\frac{\\sin{\\left(3 \\right)}}{\\cos{\\left(3 \\right)}} \\right)} + \\pi\\right) + \\log{\\left(\\sqrt{\\sin^{2}{\\left(3 \\right)} + \\cos^{2}{\\left(3 \\right)}} \\right)}\\right)}{2}\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\}$"
      ],
      "text/plain": [
       "Union({1}, ImageSet(Lambda(_n, -I*(I*(2*_n*pi + atan(sin(3)/cos(3)) + pi) + log(sqrt(sin(3)**2 + cos(3)**2)))/2), Integers), ImageSet(Lambda(_n, -I*(I*(2*_n*pi + atan(sin(3)/cos(3))) + log(sqrt(sin(3)**2 + cos(3)**2)))/2), Integers))"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset((x-1)*sin(2*x-3),x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({1},\n",
       " ImageSet(Lambda(_n, -I*(I*(2*_n*pi + atan(sin(3)/cos(3))) + log(sqrt(sin(3)**2 + cos(3)**2)))/2), Integers),\n",
       " ImageSet(Lambda(_n, -I*(I*(2*_n*pi + atan(sin(3)/cos(3)) + pi) + log(sqrt(sin(3)**2 + cos(3)**2)))/2), Integers))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-1\\right\\} \\cup \\left\\{x\\; \\middle|\\; x \\in \\mathbb{R} \\wedge \\frac{x}{2} + \\sin{\\left(x \\right)} = 0 \\right\\}$"
      ],
      "text/plain": [
       "Union(ConditionSet(x, Eq(x/2 + sin(x), 0), Reals), {-1})"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset((sin(x)+x/2)*(x+1),x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.sets.sets.Union"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(x, Eq(x/2 + sin(x), 0), Reals)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer.args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on ConditionSet in module sympy.sets.conditionset object:\n",
      "\n",
      "class ConditionSet(sympy.sets.sets.Set)\n",
      " |  ConditionSet(sym, condition, base_set=UniversalSet)\n",
      " |  \n",
      " |  Set of elements which satisfies a given condition.\n",
      " |  \n",
      " |  .. math:: \\{x \\mid \\textrm{condition}(x) = \\texttt{True}, x \\in S\\}\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import Symbol, S, ConditionSet, pi, Eq, sin, Interval\n",
      " |  >>> from sympy.abc import x, y, z\n",
      " |  \n",
      " |  >>> sin_sols = ConditionSet(x, Eq(sin(x), 0), Interval(0, 2*pi))\n",
      " |  >>> 2*pi in sin_sols\n",
      " |  True\n",
      " |  >>> pi/2 in sin_sols\n",
      " |  False\n",
      " |  >>> 3*pi in sin_sols\n",
      " |  False\n",
      " |  >>> 5 in ConditionSet(x, x**2 > 4, S.Reals)\n",
      " |  True\n",
      " |  \n",
      " |  If the value is not in the base set, the result is false:\n",
      " |  \n",
      " |  >>> 5 in ConditionSet(x, x**2 > 4, Interval(2, 4))\n",
      " |  False\n",
      " |  \n",
      " |  Notes\n",
      " |  =====\n",
      " |  \n",
      " |  Symbols with assumptions should be avoided or else the\n",
      " |  condition may evaluate without consideration of the set:\n",
      " |  \n",
      " |  >>> n = Symbol('n', negative=True)\n",
      " |  >>> cond = (n > 0); cond\n",
      " |  False\n",
      " |  >>> ConditionSet(n, cond, S.Integers)\n",
      " |  EmptySet\n",
      " |  \n",
      " |  Only free symbols can be changed by using `subs`:\n",
      " |  \n",
      " |  >>> c = ConditionSet(x, x < 1, {x, z})\n",
      " |  >>> c.subs(x, y)\n",
      " |  ConditionSet(x, x < 1, {y, z})\n",
      " |  \n",
      " |  To check if ``pi`` is in ``c`` use:\n",
      " |  \n",
      " |  >>> pi in c\n",
      " |  False\n",
      " |  \n",
      " |  If no base set is specified, the universal set is implied:\n",
      " |  \n",
      " |  >>> ConditionSet(x, x < 1).base_set\n",
      " |  UniversalSet\n",
      " |  \n",
      " |  Only symbols or symbol-like expressions can be used:\n",
      " |  \n",
      " |  >>> ConditionSet(x + 1, x + 1 < 1, S.Integers)\n",
      " |  Traceback (most recent call last):\n",
      " |  ...\n",
      " |  ValueError: non-symbol dummy not recognized in condition\n",
      " |  \n",
      " |  When the base set is a ConditionSet, the symbols will be\n",
      " |  unified if possible with preference for the outermost symbols:\n",
      " |  \n",
      " |  >>> ConditionSet(x, x < y, ConditionSet(z, z + y < 2, S.Integers))\n",
      " |  ConditionSet(x, (x < y) & (x + y < 2), Integers)\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      ConditionSet\n",
      " |      sympy.sets.sets.Set\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  as_relational(self, other)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(cls, sym, condition, base_set=UniversalSet)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  base_set\n",
      " |  \n",
      " |  bound_symbols\n",
      " |  \n",
      " |  condition\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  sym\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __annotations__ = {}\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |  \n",
      " |  __contains__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |      Return self|value.\n",
      " |  \n",
      " |  __pow__(self, exp)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __xor__(self, other)\n",
      " |  \n",
      " |  complement(self, universe)\n",
      " |      The complement of 'self' w.r.t the given universe.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(0, 1).complement(S.Reals)\n",
      " |      Union(Interval.open(-oo, 0), Interval.open(1, oo))\n",
      " |      \n",
      " |      >>> Interval(0, 1).complement(S.UniversalSet)\n",
      " |      Complement(UniversalSet, Interval(0, 1))\n",
      " |  \n",
      " |  contains(self, other)\n",
      " |      Returns a SymPy value indicating whether ``other`` is contained\n",
      " |      in ``self``: ``true`` if it is, ``false`` if it is not, else\n",
      " |      an unevaluated ``Contains`` expression (or, as in the case of\n",
      " |      ConditionSet and a union of FiniteSet/Intervals, an expression\n",
      " |      indicating the conditions for containment).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(0.5)\n",
      " |      True\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``in`` operator, but that\n",
      " |      will raise an error unless an affirmative true or false is not\n",
      " |      obtained.\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(x)\n",
      " |      (0 <= x) & (x <= 1)\n",
      " |      >>> x in Interval(0, 1)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      TypeError: did not evaluate to a bool: None\n",
      " |      \n",
      " |      The result of 'in' is a bool, not a SymPy value\n",
      " |      \n",
      " |      >>> 1 in Interval(0, 2)\n",
      " |      True\n",
      " |      >>> _ is S.true\n",
      " |      False\n",
      " |  \n",
      " |  intersect(self, other)\n",
      " |      Returns the intersection of 'self' and 'other'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      \n",
      " |      >>> Interval(1, 3).intersect(Interval(1, 2))\n",
      " |      Interval(1, 2)\n",
      " |      \n",
      " |      >>> from sympy import imageset, Lambda, symbols, S\n",
      " |      >>> n, m = symbols('n m')\n",
      " |      >>> a = imageset(Lambda(n, 2*n), S.Integers)\n",
      " |      >>> a.intersect(imageset(Lambda(m, 2*m + 1), S.Integers))\n",
      " |      EmptySet\n",
      " |  \n",
      " |  intersection(self, other)\n",
      " |      Alias for :meth:`intersect()`\n",
      " |  \n",
      " |  is_disjoint(self, other)\n",
      " |      Returns True if ``self`` and ``other`` are disjoint.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(1, 2))\n",
      " |      False\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(3, 4))\n",
      " |      True\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Disjoint_sets\n",
      " |  \n",
      " |  is_proper_subset(self, other)\n",
      " |      Returns True if ``self`` is a proper subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_proper_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_subset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_proper_superset(self, other)\n",
      " |      Returns True if ``self`` is a proper superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 0.5))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_subset(self, other)\n",
      " |      Returns True if ``self`` is a subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_subset(Interval(0, 1, left_open=True))\n",
      " |      False\n",
      " |  \n",
      " |  is_superset(self, other)\n",
      " |      Returns True if ``self`` is a superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_superset(Interval(0, 1))\n",
      " |      False\n",
      " |      >>> Interval(0, 1).is_superset(Interval(0, 1, left_open=True))\n",
      " |      True\n",
      " |  \n",
      " |  isdisjoint(self, other)\n",
      " |      Alias for :meth:`is_disjoint()`\n",
      " |  \n",
      " |  issubset(self, other)\n",
      " |      Alias for :meth:`is_subset()`\n",
      " |  \n",
      " |  issuperset(self, other)\n",
      " |      Alias for :meth:`is_superset()`\n",
      " |  \n",
      " |  powerset(self)\n",
      " |      Find the Power set of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import EmptySet, FiniteSet, Interval\n",
      " |      \n",
      " |      A power set of an empty set:\n",
      " |      \n",
      " |      >>> A = EmptySet\n",
      " |      >>> A.powerset()\n",
      " |      {EmptySet}\n",
      " |      \n",
      " |      A power set of a finite set:\n",
      " |      \n",
      " |      >>> A = FiniteSet(1, 2)\n",
      " |      >>> a, b, c = FiniteSet(1), FiniteSet(2), FiniteSet(1, 2)\n",
      " |      >>> A.powerset() == FiniteSet(a, b, c, EmptySet)\n",
      " |      True\n",
      " |      \n",
      " |      A power set of an interval:\n",
      " |      \n",
      " |      >>> Interval(1, 2).powerset()\n",
      " |      PowerSet(Interval(1, 2))\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Power_set\n",
      " |  \n",
      " |  symmetric_difference(self, other)\n",
      " |      Returns symmetric difference of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(1, 3).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(3, oo))\n",
      " |      >>> Interval(1, 10).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(10, oo))\n",
      " |      \n",
      " |      >>> from sympy import S, EmptySet\n",
      " |      >>> S.Reals.symmetric_difference(EmptySet)\n",
      " |      Reals\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      .. [1] https://en.wikipedia.org/wiki/Symmetric_difference\n",
      " |  \n",
      " |  union(self, other)\n",
      " |      Returns the union of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``+`` operator:\n",
      " |      \n",
      " |      >>> from sympy import Interval, FiniteSet\n",
      " |      >>> Interval(0, 1).union(Interval(2, 3))\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(0, 1) + Interval(2, 3)\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(1, 2, True, True) + FiniteSet(2, 3)\n",
      " |      Union({3}, Interval.Lopen(1, 2))\n",
      " |      \n",
      " |      Similarly it is possible to use the ``-`` operator for set differences:\n",
      " |      \n",
      " |      >>> Interval(0, 2) - Interval(0, 1)\n",
      " |      Interval.Lopen(1, 2)\n",
      " |      >>> Interval(1, 3) - FiniteSet(2)\n",
      " |      Union(Interval.Ropen(1, 2), Interval.Lopen(2, 3))\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  boundary\n",
      " |      The boundary or frontier of a set.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A point x is on the boundary of a set S if\n",
      " |      \n",
      " |      1.  x is in the closure of S.\n",
      " |          I.e. Every neighborhood of x contains a point in S.\n",
      " |      2.  x is not in the interior of S.\n",
      " |          I.e. There does not exist an open set centered on x contained\n",
      " |          entirely within S.\n",
      " |      \n",
      " |      There are the points on the outer rim of S.  If S is open then these\n",
      " |      points need not actually be contained within S.\n",
      " |      \n",
      " |      For example, the boundary of an interval is its start and end points.\n",
      " |      This is true regardless of whether or not the interval is open.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).boundary\n",
      " |      {0, 1}\n",
      " |      >>> Interval(0, 1, True, False).boundary\n",
      " |      {0, 1}\n",
      " |  \n",
      " |  closure\n",
      " |      Property method which returns the closure of a set.\n",
      " |      The closure is defined as the union of the set itself and its\n",
      " |      boundary.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S, Interval\n",
      " |      >>> S.Reals.closure\n",
      " |      Reals\n",
      " |      >>> Interval(0, 1).closure\n",
      " |      Interval(0, 1)\n",
      " |  \n",
      " |  inf\n",
      " |      The infimum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).inf\n",
      " |      0\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).inf\n",
      " |      0\n",
      " |  \n",
      " |  interior\n",
      " |      Property method which returns the interior of a set.\n",
      " |      The interior of a set S consists all points of S that do not\n",
      " |      belong to the boundary of S.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).interior\n",
      " |      Interval.open(0, 1)\n",
      " |      >>> Interval(0, 1).boundary.interior\n",
      " |      EmptySet\n",
      " |  \n",
      " |  is_EmptySet\n",
      " |  \n",
      " |  is_closed\n",
      " |      A property method to check whether a set is closed.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is closed if its complement is an open set. The closedness of a\n",
      " |      subset of the reals is determined with respect to R and its standard\n",
      " |      topology.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_closed\n",
      " |      True\n",
      " |  \n",
      " |  is_open\n",
      " |      Property method to check whether a set is open.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is open if and only if it has an empty intersection with its\n",
      " |      boundary. In particular, a subset A of the reals is open if and only\n",
      " |      if each one of its points is contained in an open interval that is a\n",
      " |      subset of A.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S\n",
      " |      >>> S.Reals.is_open\n",
      " |      True\n",
      " |      >>> S.Rationals.is_open\n",
      " |      False\n",
      " |  \n",
      " |  kind\n",
      " |      The kind of a Set\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      Any :class:`Set` will have kind :class:`SetKind` which is\n",
      " |      parametrised by the kind of the elements of the set. For example\n",
      " |      most sets are sets of numbers and will have kind\n",
      " |      ``SetKind(NumberKind)``. If elements of sets are different in kind than\n",
      " |      their kind will ``SetKind(UndefinedKind)``. See\n",
      " |      :class:`sympy.core.kind.Kind` for an explanation of the kind system.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Matrix, FiniteSet, EmptySet, ProductSet, PowerSet\n",
      " |      \n",
      " |      >>> FiniteSet(Matrix([1, 2])).kind\n",
      " |      SetKind(MatrixKind(NumberKind))\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind\n",
      " |      SetKind(NumberKind)\n",
      " |      \n",
      " |      >>> EmptySet.kind\n",
      " |      SetKind()\n",
      " |      \n",
      " |      A :class:`sympy.sets.powerset.PowerSet` is a set of sets:\n",
      " |      \n",
      " |      >>> PowerSet({1, 2, 3}).kind\n",
      " |      SetKind(SetKind(NumberKind))\n",
      " |      \n",
      " |      A :class:`ProductSet` represents the set of tuples of elements of\n",
      " |      other sets. Its kind is :class:`sympy.core.containers.TupleKind`\n",
      " |      parametrised by the kinds of the elements of those sets:\n",
      " |      \n",
      " |      >>> p = ProductSet(FiniteSet(1, 2), FiniteSet(3, 4))\n",
      " |      >>> list(p)\n",
      " |      [(1, 3), (2, 3), (1, 4), (2, 4)]\n",
      " |      >>> p.kind\n",
      " |      SetKind(TupleKind(NumberKind, NumberKind))\n",
      " |      \n",
      " |      When all elements of the set do not have same kind, the kind\n",
      " |      will be returned as ``SetKind(UndefinedKind)``:\n",
      " |      \n",
      " |      >>> FiniteSet(0, Matrix([1, 2])).kind\n",
      " |      SetKind(UndefinedKind)\n",
      " |      \n",
      " |      The kind of the elements of a set are given by the ``element_kind``\n",
      " |      attribute of ``SetKind``:\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind.element_kind\n",
      " |      NumberKind\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      NumberKind\n",
      " |      sympy.core.kind.UndefinedKind\n",
      " |      sympy.core.containers.TupleKind\n",
      " |      MatrixKind\n",
      " |      sympy.matrices.expressions.sets.MatrixSet\n",
      " |      sympy.sets.conditionset.ConditionSet\n",
      " |      Rationals\n",
      " |      Naturals\n",
      " |      Integers\n",
      " |      sympy.sets.fancysets.ImageSet\n",
      " |      sympy.sets.fancysets.Range\n",
      " |      sympy.sets.fancysets.ComplexRegion\n",
      " |      sympy.sets.powerset.PowerSet\n",
      " |      sympy.sets.sets.ProductSet\n",
      " |      sympy.sets.sets.Interval\n",
      " |      sympy.sets.sets.Union\n",
      " |      sympy.sets.sets.Intersection\n",
      " |      sympy.sets.sets.Complement\n",
      " |      sympy.sets.sets.EmptySet\n",
      " |      sympy.sets.sets.UniversalSet\n",
      " |      sympy.sets.sets.FiniteSet\n",
      " |      sympy.sets.sets.SymmetricDifference\n",
      " |      sympy.sets.sets.DisjointUnion\n",
      " |  \n",
      " |  measure\n",
      " |      The (Lebesgue) measure of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).measure\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).measure\n",
      " |      2\n",
      " |  \n",
      " |  sup\n",
      " |      The supremum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).sup\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).sup\n",
      " |      3\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  is_Complement = None\n",
      " |  \n",
      " |  is_ComplexRegion = False\n",
      " |  \n",
      " |  is_FiniteSet = False\n",
      " |  \n",
      " |  is_Intersection = None\n",
      " |  \n",
      " |  is_Interval = False\n",
      " |  \n",
      " |  is_ProductSet = False\n",
      " |  \n",
      " |  is_Union = False\n",
      " |  \n",
      " |  is_UniversalSet = None\n",
      " |  \n",
      " |  is_empty = None\n",
      " |  \n",
      " |  is_finite_set = None\n",
      " |  \n",
      " |  is_interval = False\n",
      " |  \n",
      " |  is_iterable = False\n",
      " |  \n",
      " |  is_number = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from https://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      A stub to allow Basic args (like Tuple) to be skipped when computing\n",
      " |      the content and primitive components of an expression.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.expr.Expr.as_content_primitive\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      Wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      Return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  has_xfree(self, s: 'set[Basic]')\n",
      " |      Return True if self has any of the patterns in s as a\n",
      " |      free argument, else False. This is like `Basic.has_free`\n",
      " |      but this will only report exact argument matches.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> f(x).has_xfree({f})\n",
      " |      False\n",
      " |      >>> f(x).has_xfree({f(x)})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x + 1})\n",
      " |      True\n",
      " |      >>> f(x + y + 1).has_xfree({x + 1})\n",
      " |      False\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : Expr\n",
      " |          A *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace(self, rule)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace does not differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __init_subclass__() from builtins.type\n",
      " |      This method is called when a class is subclassed.\n",
      " |      \n",
      " |      The default implementation does nothing. It may be\n",
      " |      overridden to extend subclasses.\n",
      " |  \n",
      " |  class_key() from builtins.type\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from builtins.type\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer.has(ConditionSet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=sin(2*x+3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function periodicity in module sympy.calculus.util:\n",
      "\n",
      "periodicity(f, symbol, check=False)\n",
      "    Tests the given function for periodicity in the given symbol.\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    f : :py:class:`~.Expr`\n",
      "        The concerned function.\n",
      "    symbol : :py:class:`~.Symbol`\n",
      "        The variable for which the period is to be determined.\n",
      "    check : bool, optional\n",
      "        The flag to verify whether the value being returned is a period or not.\n",
      "    \n",
      "    Returns\n",
      "    =======\n",
      "    \n",
      "    period\n",
      "        The period of the function is returned.\n",
      "        ``None`` is returned when the function is aperiodic or has a complex period.\n",
      "        The value of $0$ is returned as the period of a constant function.\n",
      "    \n",
      "    Raises\n",
      "    ======\n",
      "    \n",
      "    NotImplementedError\n",
      "        The value of the period computed cannot be verified.\n",
      "    \n",
      "    \n",
      "    Notes\n",
      "    =====\n",
      "    \n",
      "    Currently, we do not support functions with a complex period.\n",
      "    The period of functions having complex periodic values such\n",
      "    as ``exp``, ``sinh`` is evaluated to ``None``.\n",
      "    \n",
      "    The value returned might not be the \"fundamental\" period of the given\n",
      "    function i.e. it may not be the smallest periodic value of the function.\n",
      "    \n",
      "    The verification of the period through the ``check`` flag is not reliable\n",
      "    due to internal simplification of the given expression. Hence, it is set\n",
      "    to ``False`` by default.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    >>> from sympy import periodicity, Symbol, sin, cos, tan, exp\n",
      "    >>> x = Symbol('x')\n",
      "    >>> f = sin(x) + sin(2*x) + sin(3*x)\n",
      "    >>> periodicity(f, x)\n",
      "    2*pi\n",
      "    >>> periodicity(sin(x)*cos(x), x)\n",
      "    pi\n",
      "    >>> periodicity(exp(tan(2*x) - 1), x)\n",
      "    pi/2\n",
      "    >>> periodicity(sin(4*x)**cos(2*x), x)\n",
      "    pi\n",
      "    >>> periodicity(exp(x), x)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(periodicity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0000000000000002"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1/13)/7*13*7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(S(1)/13)/7*13*7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1.0$"
      ],
      "text/plain": [
       "1.00000000000000"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S(1/13)/7*13*7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "cube=Cube(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B,C,D,A1,B1,C1,D1=cube.vertices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 0, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 0, 0)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(1, 1, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(1, 1, 0)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 1, 1\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 1, 1)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "plane=Plane(A,C,D1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 1, \\  -1, \\  1\\right)$"
      ],
      "text/plain": [
       "(1, -1, 1)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plane.normal_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 1 & 0\\\\1 & 0 & 0\\\\x & y & z\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1, 1, 0],\n",
       "[1, 0, 0],\n",
       "[x, y, z]])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix([C,B,[x,y,z]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - z$"
      ],
      "text/plain": [
       "-z"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "det(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7a370bba98d0>"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_implicit(4-(x+2)*sqrt((x-2)**2+y**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module sympy.core.evalf in sympy.core:\n",
      "\n",
      "NAME\n",
      "    sympy.core.evalf\n",
      "\n",
      "DESCRIPTION\n",
      "    Adaptive numerical evaluation of SymPy expressions, using mpmath\n",
      "    for mathematical functions.\n",
      "\n",
      "CLASSES\n",
      "    builtins.ArithmeticError(builtins.Exception)\n",
      "        PrecisionExhausted\n",
      "    builtins.object\n",
      "        EvalfMixin\n",
      "    \n",
      "    class EvalfMixin(builtins.object)\n",
      "     |  Mixin class adding evalf capability.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "     |      Evaluate the given formula to an accuracy of *n* digits.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ==========\n",
      "     |      \n",
      "     |      subs : dict, optional\n",
      "     |          Substitute numerical values for symbols, e.g.\n",
      "     |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      "     |          dictionary.\n",
      "     |      \n",
      "     |      maxn : int, optional\n",
      "     |          Allow a maximum temporary working precision of maxn digits.\n",
      "     |      \n",
      "     |      chop : bool or number, optional\n",
      "     |          Specifies how to replace tiny real or imaginary parts in\n",
      "     |          subresults by exact zeros.\n",
      "     |      \n",
      "     |          When ``True`` the chop value defaults to standard precision.\n",
      "     |      \n",
      "     |          Otherwise the chop value is used to determine the\n",
      "     |          magnitude of \"small\" for purposes of chopping.\n",
      "     |      \n",
      "     |          >>> from sympy import N\n",
      "     |          >>> x = 1e-4\n",
      "     |          >>> N(x, chop=True)\n",
      "     |          0.000100000000000000\n",
      "     |          >>> N(x, chop=1e-5)\n",
      "     |          0.000100000000000000\n",
      "     |          >>> N(x, chop=1e-4)\n",
      "     |          0\n",
      "     |      \n",
      "     |      strict : bool, optional\n",
      "     |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      "     |          evaluate to full accuracy, given the available maxprec.\n",
      "     |      \n",
      "     |      quad : str, optional\n",
      "     |          Choose algorithm for numerical quadrature. By default,\n",
      "     |          tanh-sinh quadrature is used. For oscillatory\n",
      "     |          integrals on an infinite interval, try ``quad='osc'``.\n",
      "     |      \n",
      "     |      verbose : bool, optional\n",
      "     |          Print debug information.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      =====\n",
      "     |      \n",
      "     |      When Floats are naively substituted into an expression,\n",
      "     |      precision errors may adversely affect the result. For example,\n",
      "     |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      "     |      then subtracted, the result will be 0.\n",
      "     |      That is exactly what happens in the following:\n",
      "     |      \n",
      "     |      >>> from sympy.abc import x, y, z\n",
      "     |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      "     |      >>> (x + y - z).subs(values)\n",
      "     |      0\n",
      "     |      \n",
      "     |      Using the subs argument for evalf is the accurate way to\n",
      "     |      evaluate such an expression:\n",
      "     |      \n",
      "     |      >>> (x + y - z).evalf(subs=values)\n",
      "     |      1.00000000000000\n",
      "     |  \n",
      "     |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  __annotations__ = {}\n",
      "    \n",
      "    class PrecisionExhausted(builtins.ArithmeticError)\n",
      "     |  Method resolution order:\n",
      "     |      PrecisionExhausted\n",
      "     |      builtins.ArithmeticError\n",
      "     |      builtins.Exception\n",
      "     |      builtins.BaseException\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.ArithmeticError:\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods inherited from builtins.ArithmeticError:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.BaseException:\n",
      "     |  \n",
      "     |  __delattr__(self, name, /)\n",
      "     |      Implement delattr(self, name).\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __setattr__(self, name, value, /)\n",
      "     |      Implement setattr(self, name, value).\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  __str__(self, /)\n",
      "     |      Return str(self).\n",
      "     |  \n",
      "     |  add_note(...)\n",
      "     |      Exception.add_note(note) --\n",
      "     |      add a note to the exception\n",
      "     |  \n",
      "     |  with_traceback(...)\n",
      "     |      Exception.with_traceback(tb) --\n",
      "     |      set self.__traceback__ to tb and return self.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from builtins.BaseException:\n",
      "     |  \n",
      "     |  __cause__\n",
      "     |      exception cause\n",
      "     |  \n",
      "     |  __context__\n",
      "     |      exception context\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |  \n",
      "     |  __suppress_context__\n",
      "     |  \n",
      "     |  __traceback__\n",
      "     |  \n",
      "     |  args\n",
      "\n",
      "FUNCTIONS\n",
      "    N(x, n=15, **options)\n",
      "        Calls x.evalf(n, \\*\\*options).\n",
      "        \n",
      "        Explanations\n",
      "        ============\n",
      "        \n",
      "        Both .n() and N() are equivalent to .evalf(); use the one that you like better.\n",
      "        See also the docstring of .evalf() for information on the options.\n",
      "        \n",
      "        Examples\n",
      "        ========\n",
      "        \n",
      "        >>> from sympy import Sum, oo, N\n",
      "        >>> from sympy.abc import k\n",
      "        >>> Sum(1/k**k, (k, 1, oo))\n",
      "        Sum(k**(-k), (k, 1, oo))\n",
      "        >>> N(_, 4)\n",
      "        1.291\n",
      "    \n",
      "    add_terms(terms: 'list', prec: 'int', target_prec: 'int') -> 'tTuple[tUnion[MPF_TUP, SCALED_ZERO_TUP, None], Optional[int]]'\n",
      "        Helper for evalf_add. Adds a list of (mpfval, accuracy) terms.\n",
      "        \n",
      "        Returns\n",
      "        =======\n",
      "        \n",
      "        - None, None if there are no non-zero terms;\n",
      "        - terms[0] if there is only 1 term;\n",
      "        - scaled_zero if the sum of the terms produces a zero by cancellation\n",
      "          e.g. mpfs representing 1 and -1 would produce a scaled zero which need\n",
      "          special handling since they are not actually zero and they are purposely\n",
      "          malformed to ensure that they cannot be used in anything but accuracy\n",
      "          calculations;\n",
      "        - a tuple that is scaled to target_prec that corresponds to the\n",
      "          sum of the terms.\n",
      "        \n",
      "        The returned mpf tuple will be normalized to target_prec; the input\n",
      "        prec is used to define the working precision.\n",
      "        \n",
      "        XXX explain why this is needed and why one cannot just loop using mpf_add\n",
      "    \n",
      "    as_mpmath(x: 'Any', prec: 'int', options: 'OPT_DICT') -> 'tUnion[mpc, mpf]'\n",
      "    \n",
      "    bitcount(n)\n",
      "        Return smallest integer, b, such that |n|/2**b < 1.\n",
      "    \n",
      "    check_convergence(numer: \"'Expr'\", denom: \"'Expr'\", n: \"'Symbol'\") -> 'tTuple[int, Any, Any]'\n",
      "        Returns\n",
      "        =======\n",
      "        \n",
      "        (h, g, p) where\n",
      "        -- h is:\n",
      "            > 0 for convergence of rate 1/factorial(n)**h\n",
      "            < 0 for divergence of rate factorial(n)**(-h)\n",
      "            = 0 for geometric or polynomial convergence or divergence\n",
      "        \n",
      "        -- abs(g) is:\n",
      "            > 1 for geometric convergence of rate 1/h**n\n",
      "            < 1 for geometric divergence of rate h**n\n",
      "            = 1 for polynomial convergence or divergence\n",
      "        \n",
      "            (g < 0 indicates an alternating series)\n",
      "        \n",
      "        -- p is:\n",
      "            > 1 for polynomial convergence of rate 1/n**h\n",
      "            <= 1 for polynomial divergence of rate n**(-h)\n",
      "    \n",
      "    check_target(expr: \"'Expr'\", result: 'TMP_RES', prec: 'int')\n",
      "    \n",
      "    chop_parts(value: 'TMP_RES', prec: 'int') -> 'TMP_RES'\n",
      "        Chop off tiny real or complex parts.\n",
      "    \n",
      "    complex_accuracy(result: 'TMP_RES') -> 'tUnion[int, Any]'\n",
      "        Returns relative accuracy of a complex number with given accuracies\n",
      "        for the real and imaginary parts. The relative accuracy is defined\n",
      "        in the complex norm sense as ||z|+|error|| / |z| where error\n",
      "        is equal to (real absolute error) + (imag absolute error)*i.\n",
      "        \n",
      "        The full expression for the (logarithmic) error can be approximated\n",
      "        easily by using the max norm to approximate the complex norm.\n",
      "        \n",
      "        In the worst case (re and im equal), this is wrong by a factor\n",
      "        sqrt(2), or by log2(sqrt(2)) = 0.5 bit.\n",
      "    \n",
      "    do_integral(expr: \"'Integral'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf(x: \"'Expr'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "        Evaluate the ``Expr`` instance, ``x``\n",
      "        to a binary precision of ``prec``. This\n",
      "        function is supposed to be used internally.\n",
      "        \n",
      "        Parameters\n",
      "        ==========\n",
      "        \n",
      "        x : Expr\n",
      "            The formula to evaluate to a float.\n",
      "        prec : int\n",
      "            The binary precision that the output should have.\n",
      "        options : dict\n",
      "            A dictionary with the same entries as\n",
      "            ``EvalfMixin.evalf`` and in addition,\n",
      "            ``maxprec`` which is the maximum working precision.\n",
      "        \n",
      "        Returns\n",
      "        =======\n",
      "        \n",
      "        An optional tuple, ``(re, im, re_acc, im_acc)``\n",
      "        which are the real, imaginary, real accuracy\n",
      "        and imaginary accuracy respectively. ``re`` is\n",
      "        an mpf value tuple and so is ``im``. ``re_acc``\n",
      "        and ``im_acc`` are ints.\n",
      "        \n",
      "        NB: all these return values can be ``None``.\n",
      "        If all values are ``None``, then that represents 0.\n",
      "        Note that 0 is also represented as ``fzero = (0, 0, 0, 0)``.\n",
      "    \n",
      "    evalf_abs(expr: \"'Abs'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_add(v: \"'Add'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_alg_num(a: \"'AlgebraicNumber'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_atan(v: \"'atan'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_ceiling(expr: \"'ceiling'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_exp(expr: \"'exp'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_float(expr: \"'Float'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_floor(expr: \"'floor'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_im(expr: \"'im'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_integer(expr: \"'Integer'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_integral(expr: \"'Integral'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_log(expr: \"'log'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_mul(v: \"'Mul'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_piecewise(expr: \"'Expr'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_pow(v: \"'Pow'\", prec: 'int', options) -> 'TMP_RES'\n",
      "    \n",
      "    evalf_prod(expr: \"'Product'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_rational(expr: \"'Rational'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_re(expr: \"'re'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_subs(prec: 'int', subs: 'dict') -> 'dict'\n",
      "        Change all Float entries in `subs` to have precision prec.\n",
      "    \n",
      "    evalf_sum(expr: \"'Sum'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_symbol(x: \"'Expr'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    evalf_trig(v: \"'Expr'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "        This function handles sin and cos of complex arguments.\n",
      "        \n",
      "        TODO: should also handle tan of complex arguments.\n",
      "    \n",
      "    fastlog(x: 'Optional[MPF_TUP]') -> 'tUnion[int, Any]'\n",
      "        Fast approximation of log2(x) for an mpf value tuple x.\n",
      "        \n",
      "        Explanation\n",
      "        ===========\n",
      "        \n",
      "        Calculated as exponent + width of mantissa. This is an\n",
      "        approximation for two reasons: 1) it gives the ceil(log2(abs(x)))\n",
      "        value and 2) it is too high by 1 in the case that x is an exact\n",
      "        power of 2. Although this is easy to remedy by testing to see if\n",
      "        the odd mpf mantissa is 1 (indicating that one was dealing with\n",
      "        an exact power of 2) that would decrease the speed and is not\n",
      "        necessary as this is only being used as an approximation for the\n",
      "        number of bits in x. The correct return value could be written as\n",
      "        \"x[2] + (x[3] if x[1] != 1 else 0)\".\n",
      "            Since mpf tuples always have an odd mantissa, no check is done\n",
      "        to see if the mantissa is a multiple of 2 (in which case the\n",
      "        result would be too large by 1).\n",
      "        \n",
      "        Examples\n",
      "        ========\n",
      "        \n",
      "        >>> from sympy import log\n",
      "        >>> from sympy.core.evalf import fastlog, bitcount\n",
      "        >>> s, m, e = 0, 5, 1\n",
      "        >>> bc = bitcount(m)\n",
      "        >>> n = [1, -1][s]*m*2**e\n",
      "        >>> n, (log(n)/log(2)).evalf(2), fastlog((s, m, e, bc))\n",
      "        (10, 3.3, 4)\n",
      "    \n",
      "    finalize_complex(re: 'MPF_TUP', im: 'MPF_TUP', prec: 'int') -> 'TMP_RES'\n",
      "    \n",
      "    from_man_exp = _mpmath_create(...)\n",
      "        _mpmath_create(...): helper function for mpmath.\n",
      "    \n",
      "    get_abs(expr: \"'Expr'\", prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "    \n",
      "    get_complex_part(expr: \"'Expr'\", no: 'int', prec: 'int', options: 'OPT_DICT') -> 'TMP_RES'\n",
      "        no = 0 for real part, no = 1 for imaginary part\n",
      "    \n",
      "    get_integer_part(expr: \"'Expr'\", no: 'int', options: 'OPT_DICT', return_ints=False) -> 'tUnion[TMP_RES, tTuple[int, int]]'\n",
      "        With no = 1, computes ceiling(expr)\n",
      "        With no = -1, computes floor(expr)\n",
      "        \n",
      "        Note: this function either gives the exact result or signals failure.\n",
      "    \n",
      "    hypsum(expr: \"'Expr'\", n: \"'Symbol'\", start: 'int', prec: 'int') -> 'mpf'\n",
      "        Sum a rapidly convergent infinite hypergeometric series with\n",
      "        given general term, e.g. e = hypsum(1/factorial(n), n). The\n",
      "        quotient between successive terms must be a quotient of integer\n",
      "        polynomials.\n",
      "    \n",
      "    iszero(mpf: 'tUnion[MPF_TUP, SCALED_ZERO_TUP, None]', scaled=False) -> 'Optional[bool]'\n",
      "    \n",
      "    mpmath_bitcount = bit_length(...)\n",
      "        bit_length(x) -> int\n",
      "        \n",
      "        Return the number of significant bits in the radix-2\n",
      "        representation of x. Note: bit_length(0) returns 0.\n",
      "    \n",
      "    normalize = _mpmath_normalize(...)\n",
      "        _mpmath_normalize(...): helper function for mpmath.\n",
      "    \n",
      "    pure_complex(v: \"'Expr'\", or_real=False) -> \"tuple['Number', 'Number'] | None\"\n",
      "        Return a and b if v matches a + I*b where b is not zero and\n",
      "        a and b are Numbers, else None. If `or_real` is True then 0 will\n",
      "        be returned for `b` if `v` is a real number.\n",
      "        \n",
      "        Examples\n",
      "        ========\n",
      "        \n",
      "        >>> from sympy.core.evalf import pure_complex\n",
      "        >>> from sympy import sqrt, I, S\n",
      "        >>> a, b, surd = S(2), S(3), sqrt(2)\n",
      "        >>> pure_complex(a)\n",
      "        >>> pure_complex(a, or_real=True)\n",
      "        (2, 0)\n",
      "        >>> pure_complex(surd)\n",
      "        >>> pure_complex(a + b*I)\n",
      "        (2, 3)\n",
      "        >>> pure_complex(I)\n",
      "        (0, 1)\n",
      "    \n",
      "    quad_to_mpmath(q, ctx=None)\n",
      "        Turn the quad returned by ``evalf`` into an ``mpf`` or ``mpc``.\n",
      "    \n",
      "    scaled_zero(mag: 'tUnion[SCALED_ZERO_TUP, int]', sign=1) -> 'tUnion[MPF_TUP, tTuple[SCALED_ZERO_TUP, int]]'\n",
      "        Return an mpf representing a power of two with magnitude ``mag``\n",
      "        and -1 for precision. Or, if ``mag`` is a scaled_zero tuple, then just\n",
      "        remove the sign from within the list that it was initially wrapped\n",
      "        in.\n",
      "        \n",
      "        Examples\n",
      "        ========\n",
      "        \n",
      "        >>> from sympy.core.evalf import scaled_zero\n",
      "        >>> from sympy import Float\n",
      "        >>> z, p = scaled_zero(100)\n",
      "        >>> z, p\n",
      "        (([0], 1, 100, 1), -1)\n",
      "        >>> ok = scaled_zero(z)\n",
      "        >>> ok\n",
      "        (0, 1, 100, 1)\n",
      "        >>> Float(ok)\n",
      "        1.26765060022823e+30\n",
      "        >>> Float(ok, p)\n",
      "        0.e+30\n",
      "        >>> ok, p = scaled_zero(100, -1)\n",
      "        >>> Float(scaled_zero(ok), p)\n",
      "        -0.e+30\n",
      "\n",
      "DATA\n",
      "    Callable = typing.Callable\n",
      "        Deprecated alias to collections.abc.Callable.\n",
      "        \n",
      "        Callable[[int], str] signifies a function that takes a single\n",
      "        parameter of type int and returns a str.\n",
      "        \n",
      "        The subscription syntax must always be used with exactly two\n",
      "        values: the argument list and the return type.\n",
      "        The argument list must be a list of types, a ParamSpec,\n",
      "        Concatenate or ellipsis. The return type must be a single type.\n",
      "        \n",
      "        There is no syntax to indicate optional or keyword arguments;\n",
      "        such function types are rarely used as callback types.\n",
      "    \n",
      "    DEFAULT_MAXPREC = 333\n",
      "    INF = inf\n",
      "    LG10 = 3.3219280948873626\n",
      "    List = typing.List\n",
      "        A generic version of list.\n",
      "    \n",
      "    MINUS_INF = -inf\n",
      "    MPF_TUP = typing.Tuple[int, int, int, int]\n",
      "    OPT_DICT = typing.Dict[str, typing.Any]\n",
      "    Optional = typing.Optional\n",
      "        Optional[X] is equivalent to Union[X, None].\n",
      "    \n",
      "    S = S\n",
      "    SCALED_ZERO_TUP = typing.Tuple[typing.List[int], int, int, int]\n",
      "    SYMPY_INTS = (<class 'int'>, <class 'mpz'>)\n",
      "    TYPE_CHECKING = False\n",
      "    Type = typing.Type\n",
      "        Deprecated alias to builtins.type.\n",
      "        \n",
      "        builtins.type or typing.Type can be used to annotate class objects.\n",
      "        For example, suppose we have the following classes::\n",
      "        \n",
      "            class User: ...  # Abstract base for User classes\n",
      "            class BasicUser(User): ...\n",
      "            class ProUser(User): ...\n",
      "            class TeamUser(User): ...\n",
      "        \n",
      "        And a function that takes a class argument that's a subclass of\n",
      "        User and returns an instance of the corresponding class::\n",
      "        \n",
      "            U = TypeVar('U', bound=User)\n",
      "            def new_user(user_class: Type[U]) -> U:\n",
      "                user = user_class()\n",
      "                # (Here we could write the user object to a database)\n",
      "                return user\n",
      "        \n",
      "            joe = new_user(BasicUser)\n",
      "        \n",
      "        At this point the type checker knows that joe has type BasicUser.\n",
      "    \n",
      "    __annotations__ = {'evalf_table': \"tDict[Type['Expr'], Callable[['Expr...\n",
      "    evalf_table = {<class 'sympy.core.symbol.Symbol'>: <function evalf_sym...\n",
      "    fhalf = (0, mpz(1), -1, 1)\n",
      "    finf = (0, mpz(0), -456, -2)\n",
      "    fnan = (0, mpz(0), -123, -1)\n",
      "    fninf = (1, mpz(0), -789, -3)\n",
      "    fnone = (1, mpz(1), 0, 1)\n",
      "    fone = (0, mpz(1), 0, 1)\n",
      "    fzero = (0, mpz(0), 0, 0)\n",
      "    mp = <mpmath.ctx_mp.MPContext object>\n",
      "    mpmath_inf = mpf('+inf')\n",
      "    rnd = 'n'\n",
      "    round_nearest = 'n'\n",
      "    tDict = typing.Dict\n",
      "        A generic version of dict.\n",
      "    \n",
      "    tTuple = typing.Tuple\n",
      "        Deprecated alias to builtins.tuple.\n",
      "        \n",
      "        Tuple[X, Y] is the cross-product type of X and Y.\n",
      "        \n",
      "        Example: Tuple[T1, T2] is a tuple of two elements corresponding\n",
      "        to type variables T1 and T2.  Tuple[int, float, str] is a tuple\n",
      "        of an int, a float and a string.\n",
      "        \n",
      "        To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].\n",
      "    \n",
      "    tUnion = typing.Union\n",
      "        Union type; Union[X, Y] means either X or Y.\n",
      "        \n",
      "        On Python 3.10 and higher, the | operator\n",
      "        can also be used to denote unions;\n",
      "        X | Y means the same thing to the type checker as Union[X, Y].\n",
      "        \n",
      "        To define a union, use e.g. Union[int, str]. Details:\n",
      "        - The arguments must be types and there must be at least one.\n",
      "        - None as an argument is a special case and is replaced by\n",
      "          type(None).\n",
      "        - Unions of unions are flattened, e.g.::\n",
      "        \n",
      "            assert Union[Union[int, str], float] == Union[int, str, float]\n",
      "        \n",
      "        - Unions of a single argument vanish, e.g.::\n",
      "        \n",
      "            assert Union[int] == int  # The constructor actually returns int\n",
      "        \n",
      "        - Redundant arguments are skipped, e.g.::\n",
      "        \n",
      "            assert Union[int, str, int] == Union[int, str]\n",
      "        \n",
      "        - When comparing unions, the argument order is ignored, e.g.::\n",
      "        \n",
      "            assert Union[int, str] == Union[str, int]\n",
      "        \n",
      "        - You cannot subclass or instantiate a union.\n",
      "        - You can use Optional[X] as a shorthand for Union[X, None].\n",
      "\n",
      "FILE\n",
      "    /home/huang/anaconda3/lib/python3.11/site-packages/sympy/core/evalf.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(evalf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function N in module sympy.core.evalf:\n",
      "\n",
      "N(x, n=15, **options)\n",
      "    Calls x.evalf(n, \\*\\*options).\n",
      "    \n",
      "    Explanations\n",
      "    ============\n",
      "    \n",
      "    Both .n() and N() are equivalent to .evalf(); use the one that you like better.\n",
      "    See also the docstring of .evalf() for information on the options.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy import Sum, oo, N\n",
      "    >>> from sympy.abc import k\n",
      "    >>> Sum(1/k**k, (k, 1, oo))\n",
      "    Sum(k**(-k), (k, 1, oo))\n",
      "    >>> N(_, 4)\n",
      "    1.291\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Prism}\\left(\\operatorname{Point3D}\\left(\\frac{\\sqrt{3}}{3}, 0, 0\\right), \\operatorname{Point3D}\\left(- \\frac{\\sqrt{3}}{6}, \\frac{1}{2}, 0\\right), \\operatorname{Point3D}\\left(- \\frac{\\sqrt{3}}{6}, - \\frac{1}{2}, 0\\right), \\operatorname{Point3D}\\left(\\frac{\\sqrt{3}}{3}, 0, 1\\right), \\operatorname{Point3D}\\left(- \\frac{\\sqrt{3}}{6}, \\frac{1}{2}, 1\\right), \\operatorname{Point3D}\\left(- \\frac{\\sqrt{3}}{6}, - \\frac{1}{2}, 1\\right)\\right)$"
      ],
      "text/plain": [
       "Prism(Point3D(sqrt(3)/3, 0, 0), Point3D(-sqrt(3)/6, 1/2, 0), Point3D(-sqrt(3)/6, -1/2, 0), Point3D(sqrt(3)/3, 0, 1), Point3D(-sqrt(3)/6, 1/2, 1), Point3D(-sqrt(3)/6, -1/2, 1))"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prism = Prism(RegularPolygon(Point(0,0),1/sqrt(3),3),1)\n",
    "prism"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prism(Point3D(sqrt(3)/3, 0, 0), Point3D(-sqrt(3)/6, 1/2, 0), Point3D(-sqrt(3)/6, -1/2, 0), Point3D(sqrt(3)/3, 0, 1), Point3D(-sqrt(3)/6, 1/2, 1), Point3D(-sqrt(3)/6, -1/2, 1))\n"
     ]
    }
   ],
   "source": [
    "print(prism)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function smtlib_code in module sympy.printing.smtlib:\n",
      "\n",
      "smtlib_code(expr, auto_assert=True, auto_declare=True, precision=None, symbol_table=None, known_types=None, known_constants=None, known_functions=None, prefix_expressions=None, suffix_expressions=None, log_warn=None)\n",
      "    Converts ``expr`` to a string of smtlib code.\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    expr : Expr | List[Expr]\n",
      "        A SymPy expression or system to be converted.\n",
      "    auto_assert : bool, optional\n",
      "        If false, do not modify expr and produce only the S-Expression equivalent of expr.\n",
      "        If true, assume expr is a system and assert each boolean element.\n",
      "    auto_declare : bool, optional\n",
      "        If false, do not produce declarations for the symbols used in expr.\n",
      "        If true, prepend all necessary declarations for variables used in expr based on symbol_table.\n",
      "    precision : integer, optional\n",
      "        The ``evalf(..)`` precision for numbers such as pi.\n",
      "    symbol_table : dict, optional\n",
      "        A dictionary where keys are ``Symbol`` or ``Function`` instances and values are their Python type i.e. ``bool``, ``int``, ``float``, or ``Callable[...]``.\n",
      "        If incomplete, an attempt will be made to infer types from ``expr``.\n",
      "    known_types: dict, optional\n",
      "        A dictionary where keys are ``bool``, ``int``, ``float`` etc. and values are their corresponding SMT type names.\n",
      "        If not given, a partial listing compatible with several solvers will be used.\n",
      "    known_functions : dict, optional\n",
      "        A dictionary where keys are ``Function``, ``Relational``, ``BooleanFunction``, or ``Expr`` instances and values are their SMT string representations.\n",
      "        If not given, a partial listing optimized for dReal solver (but compatible with others) will be used.\n",
      "    known_constants: dict, optional\n",
      "        A dictionary where keys are ``NumberSymbol`` instances and values are their SMT variable names.\n",
      "        When using this feature, extra caution must be taken to avoid naming collisions between user symbols and listed constants.\n",
      "        If not given, constants will be expanded inline i.e. ``3.14159`` instead of ``MY_SMT_VARIABLE_FOR_PI``.\n",
      "    prefix_expressions: list, optional\n",
      "        A list of lists of ``str`` and/or expressions to convert into SMTLib and prefix to the output.\n",
      "    suffix_expressions: list, optional\n",
      "        A list of lists of ``str`` and/or expressions to convert into SMTLib and postfix to the output.\n",
      "    log_warn: lambda function, optional\n",
      "        A function to record all warnings during potentially risky operations.\n",
      "        Soundness is a core value in SMT solving, so it is good to log all assumptions made.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    >>> from sympy import smtlib_code, symbols, sin, Eq\n",
      "    >>> x = symbols('x')\n",
      "    >>> smtlib_code(sin(x).series(x).removeO(), log_warn=print)\n",
      "    Could not infer type of `x`. Defaulting to float.\n",
      "    Non-Boolean expression `x**5/120 - x**3/6 + x` will not be asserted. Converting to SMTLib verbatim.\n",
      "    '(declare-const x Real)\\n(+ x (* (/ -1 6) (pow x 3)) (* (/ 1 120) (pow x 5)))'\n",
      "    \n",
      "    >>> from sympy import Rational\n",
      "    >>> x, y, tau = symbols(\"x, y, tau\")\n",
      "    >>> smtlib_code((2*tau)**Rational(7, 2), log_warn=print)\n",
      "    Could not infer type of `tau`. Defaulting to float.\n",
      "    Non-Boolean expression `8*sqrt(2)*tau**(7/2)` will not be asserted. Converting to SMTLib verbatim.\n",
      "    '(declare-const tau Real)\\n(* 8 (pow 2 (/ 1 2)) (pow tau (/ 7 2)))'\n",
      "    \n",
      "    ``Piecewise`` expressions are implemented with ``ite`` expressions by default.\n",
      "    Note that if the ``Piecewise`` lacks a default term, represented by\n",
      "    ``(expr, True)`` then an error will be thrown.  This is to prevent\n",
      "    generating an expression that may not evaluate to anything.\n",
      "    \n",
      "    >>> from sympy import Piecewise\n",
      "    >>> pw = Piecewise((x + 1, x > 0), (x, True))\n",
      "    >>> smtlib_code(Eq(pw, 3), symbol_table={x: float}, log_warn=print)\n",
      "    '(declare-const x Real)\\n(assert (= (ite (> x 0) (+ 1 x) x) 3))'\n",
      "    \n",
      "    Custom printing can be defined for certain types by passing a dictionary of\n",
      "    PythonType : \"SMT Name\" to the ``known_types``, ``known_constants``, and ``known_functions`` kwargs.\n",
      "    \n",
      "    >>> from typing import Callable\n",
      "    >>> from sympy import Function, Add\n",
      "    >>> f = Function('f')\n",
      "    >>> g = Function('g')\n",
      "    >>> smt_builtin_funcs = {  # functions our SMT solver will understand\n",
      "    ...   f: \"existing_smtlib_fcn\",\n",
      "    ...   Add: \"sum\",\n",
      "    ... }\n",
      "    >>> user_def_funcs = {  # functions defined by the user must have their types specified explicitly\n",
      "    ...   g: Callable[[int], float],\n",
      "    ... }\n",
      "    >>> smtlib_code(f(x) + g(x), symbol_table=user_def_funcs, known_functions=smt_builtin_funcs, log_warn=print)\n",
      "    Non-Boolean expression `f(x) + g(x)` will not be asserted. Converting to SMTLib verbatim.\n",
      "    '(declare-const x Int)\\n(declare-fun g (Int) Real)\\n(sum (existing_smtlib_fcn x) (g x))'\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(smtlib_code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class RegularPolygon in module sympy.geometry.polygon:\n",
      "\n",
      "class RegularPolygon(Polygon)\n",
      " |  RegularPolygon(c, r, n, rot=0, **kwargs)\n",
      " |  \n",
      " |  A regular polygon.\n",
      " |  \n",
      " |  Such a polygon has all internal angles equal and all sides the same length.\n",
      " |  \n",
      " |  Parameters\n",
      " |  ==========\n",
      " |  \n",
      " |  center : Point\n",
      " |  radius : number or Basic instance\n",
      " |      The distance from the center to a vertex\n",
      " |  n : int\n",
      " |      The number of sides\n",
      " |  \n",
      " |  Attributes\n",
      " |  ==========\n",
      " |  \n",
      " |  vertices\n",
      " |  center\n",
      " |  radius\n",
      " |  rotation\n",
      " |  apothem\n",
      " |  interior_angle\n",
      " |  exterior_angle\n",
      " |  circumcircle\n",
      " |  incircle\n",
      " |  angles\n",
      " |  \n",
      " |  Raises\n",
      " |  ======\n",
      " |  \n",
      " |  GeometryError\n",
      " |      If the `center` is not a Point, or the `radius` is not a number or Basic\n",
      " |      instance, or the number of sides, `n`, is less than three.\n",
      " |  \n",
      " |  Notes\n",
      " |  =====\n",
      " |  \n",
      " |  A RegularPolygon can be instantiated with Polygon with the kwarg n.\n",
      " |  \n",
      " |  Regular polygons are instantiated with a center, radius, number of sides\n",
      " |  and a rotation angle. Whereas the arguments of a Polygon are vertices, the\n",
      " |  vertices of the RegularPolygon must be obtained with the vertices method.\n",
      " |  \n",
      " |  See Also\n",
      " |  ========\n",
      " |  \n",
      " |  sympy.geometry.point.Point, Polygon\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import RegularPolygon, Point\n",
      " |  >>> r = RegularPolygon(Point(0, 0), 5, 3)\n",
      " |  >>> r\n",
      " |  RegularPolygon(Point2D(0, 0), 5, 3, 0)\n",
      " |  >>> r.vertices[0]\n",
      " |  Point2D(5, 0)\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      RegularPolygon\n",
      " |      Polygon\n",
      " |      sympy.geometry.entity.GeometrySet\n",
      " |      sympy.geometry.entity.GeometryEntity\n",
      " |      sympy.sets.sets.Set\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __eq__(self, o)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from https://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __hash__(self)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      String representation of a GeometryEntity that can be evaluated\n",
      " |      by sympy.\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      String representation of a GeometryEntity.\n",
      " |  \n",
      " |  encloses_point(self, p)\n",
      " |      Return True if p is enclosed by (is inside of) self.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Being on the border of self is considered False.\n",
      " |      \n",
      " |      The general Polygon.encloses_point method is called only if\n",
      " |      a point is not within or beyond the incircle or circumcircle,\n",
      " |      respectively.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      p : Point\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      encloses_point : True, False or None\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.ellipse.Ellipse.encloses_point\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, S, Point, Symbol\n",
      " |      >>> p = RegularPolygon((0, 0), 3, 4)\n",
      " |      >>> p.encloses_point(Point(0, 0))\n",
      " |      True\n",
      " |      >>> r, R = p.inradius, p.circumradius\n",
      " |      >>> p.encloses_point(Point((r + R)/2, 0))\n",
      " |      True\n",
      " |      >>> p.encloses_point(Point(R/2, R/2 + (R - r)/10))\n",
      " |      False\n",
      " |      >>> t = Symbol('t', real=True)\n",
      " |      >>> p.encloses_point(p.arbitrary_point().subs(t, S.Half))\n",
      " |      False\n",
      " |      >>> p.encloses_point(Point(5, 5))\n",
      " |      False\n",
      " |  \n",
      " |  reflect(self, line)\n",
      " |      Override GeometryEntity.reflect since this is not made of only\n",
      " |      points.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Line\n",
      " |      \n",
      " |      >>> RegularPolygon((0, 0), 1, 4).reflect(Line((0, 1), slope=-2))\n",
      " |      RegularPolygon(Point2D(4/5, 2/5), -1, 4, atan(4/3))\n",
      " |  \n",
      " |  rotate(self, angle, pt=None)\n",
      " |      Override GeometryEntity.rotate to first rotate the RegularPolygon\n",
      " |      about its center.\n",
      " |      \n",
      " |      >>> from sympy import Point, RegularPolygon, pi\n",
      " |      >>> t = RegularPolygon(Point(1, 0), 1, 3)\n",
      " |      >>> t.vertices[0] # vertex on x-axis\n",
      " |      Point2D(2, 0)\n",
      " |      >>> t.rotate(pi/2).vertices[0] # vertex on y axis now\n",
      " |      Point2D(0, 2)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      rotation\n",
      " |      spin : Rotates a RegularPolygon in place\n",
      " |  \n",
      " |  scale(self, x=1, y=1, pt=None)\n",
      " |      Override GeometryEntity.scale since it is the radius that must be\n",
      " |      scaled (if x == y) or else a new Polygon must be returned.\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon\n",
      " |      \n",
      " |      Symmetric scaling returns a RegularPolygon:\n",
      " |      \n",
      " |      >>> RegularPolygon((0, 0), 1, 4).scale(2, 2)\n",
      " |      RegularPolygon(Point2D(0, 0), 2, 4, 0)\n",
      " |      \n",
      " |      Asymmetric scaling returns a kite as a Polygon:\n",
      " |      \n",
      " |      >>> RegularPolygon((0, 0), 1, 4).scale(2, 1)\n",
      " |      Polygon(Point2D(2, 0), Point2D(0, 1), Point2D(-2, 0), Point2D(0, -1))\n",
      " |  \n",
      " |  spin(self, angle)\n",
      " |      Increment *in place* the virtual Polygon's rotation by ccw angle.\n",
      " |      \n",
      " |      See also: rotate method which moves the center.\n",
      " |      \n",
      " |      >>> from sympy import Polygon, Point, pi\n",
      " |      >>> r = Polygon(Point(0,0), 1, n=3)\n",
      " |      >>> r.vertices[0]\n",
      " |      Point2D(1, 0)\n",
      " |      >>> r.spin(pi/6)\n",
      " |      >>> r.vertices[0]\n",
      " |      Point2D(sqrt(3)/2, 1/2)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      rotation\n",
      " |      rotate : Creates a copy of the RegularPolygon rotated about a Point\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(self, c, r, n, rot=0, **kwargs)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  angles\n",
      " |      Returns a dictionary with keys, the vertices of the Polygon,\n",
      " |      and values, the interior angle at each vertex.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> r = RegularPolygon(Point(0, 0), 5, 3)\n",
      " |      >>> r.angles\n",
      " |      {Point2D(-5/2, -5*sqrt(3)/2): pi/3,\n",
      " |       Point2D(-5/2, 5*sqrt(3)/2): pi/3,\n",
      " |       Point2D(5, 0): pi/3}\n",
      " |  \n",
      " |  apothem\n",
      " |      The inradius of the RegularPolygon.\n",
      " |      \n",
      " |      The apothem/inradius is the radius of the inscribed circle.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      apothem : number or instance of Basic\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.line.Segment.length, sympy.geometry.ellipse.Circle.radius\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> radius = Symbol('r')\n",
      " |      >>> rp = RegularPolygon(Point(0, 0), radius, 4)\n",
      " |      >>> rp.apothem\n",
      " |      sqrt(2)*r/2\n",
      " |  \n",
      " |  area\n",
      " |      Returns the area.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon\n",
      " |      >>> square = RegularPolygon((0, 0), 1, 4)\n",
      " |      >>> square.area\n",
      " |      2\n",
      " |      >>> _ == square.length**2\n",
      " |      True\n",
      " |  \n",
      " |  args\n",
      " |      Returns the center point, the radius,\n",
      " |      the number of sides, and the orientation angle.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> r = RegularPolygon(Point(0, 0), 5, 3)\n",
      " |      >>> r.args\n",
      " |      (Point2D(0, 0), 5, 3, 0)\n",
      " |  \n",
      " |  center\n",
      " |      The center of the RegularPolygon\n",
      " |      \n",
      " |      This is also the center of the circumscribing circle.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      center : Point\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.point.Point, sympy.geometry.ellipse.Ellipse.center\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> rp = RegularPolygon(Point(0, 0), 5, 4)\n",
      " |      >>> rp.center\n",
      " |      Point2D(0, 0)\n",
      " |  \n",
      " |  centroid\n",
      " |      The center of the RegularPolygon\n",
      " |      \n",
      " |      This is also the center of the circumscribing circle.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      center : Point\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.point.Point, sympy.geometry.ellipse.Ellipse.center\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> rp = RegularPolygon(Point(0, 0), 5, 4)\n",
      " |      >>> rp.center\n",
      " |      Point2D(0, 0)\n",
      " |  \n",
      " |  circumcenter\n",
      " |      Alias for center.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> rp = RegularPolygon(Point(0, 0), 5, 4)\n",
      " |      >>> rp.circumcenter\n",
      " |      Point2D(0, 0)\n",
      " |  \n",
      " |  circumcircle\n",
      " |      The circumcircle of the RegularPolygon.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      circumcircle : Circle\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      circumcenter, sympy.geometry.ellipse.Circle\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> rp = RegularPolygon(Point(0, 0), 4, 8)\n",
      " |      >>> rp.circumcircle\n",
      " |      Circle(Point2D(0, 0), 4)\n",
      " |  \n",
      " |  circumradius\n",
      " |      Alias for radius.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> radius = Symbol('r')\n",
      " |      >>> rp = RegularPolygon(Point(0, 0), radius, 4)\n",
      " |      >>> rp.circumradius\n",
      " |      r\n",
      " |  \n",
      " |  exterior_angle\n",
      " |      Measure of the exterior angles.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      exterior_angle : number\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.line.LinearEntity.angle_between\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> rp = RegularPolygon(Point(0, 0), 4, 8)\n",
      " |      >>> rp.exterior_angle\n",
      " |      pi/4\n",
      " |  \n",
      " |  incircle\n",
      " |      The incircle of the RegularPolygon.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      incircle : Circle\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      inradius, sympy.geometry.ellipse.Circle\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> rp = RegularPolygon(Point(0, 0), 4, 7)\n",
      " |      >>> rp.incircle\n",
      " |      Circle(Point2D(0, 0), 4*cos(pi/7))\n",
      " |  \n",
      " |  inradius\n",
      " |      Alias for apothem.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> radius = Symbol('r')\n",
      " |      >>> rp = RegularPolygon(Point(0, 0), radius, 4)\n",
      " |      >>> rp.inradius\n",
      " |      sqrt(2)*r/2\n",
      " |  \n",
      " |  interior_angle\n",
      " |      Measure of the interior angles.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      interior_angle : number\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.line.LinearEntity.angle_between\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> rp = RegularPolygon(Point(0, 0), 4, 8)\n",
      " |      >>> rp.interior_angle\n",
      " |      3*pi/4\n",
      " |  \n",
      " |  length\n",
      " |      Returns the length of the sides.\n",
      " |      \n",
      " |      The half-length of the side and the apothem form two legs\n",
      " |      of a right triangle whose hypotenuse is the radius of the\n",
      " |      regular polygon.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> s = square_in_unit_circle = RegularPolygon((0, 0), 1, 4)\n",
      " |      >>> s.length\n",
      " |      sqrt(2)\n",
      " |      >>> sqrt((_/2)**2 + s.apothem**2) == s.radius\n",
      " |      True\n",
      " |  \n",
      " |  radius\n",
      " |      Radius of the RegularPolygon\n",
      " |      \n",
      " |      This is also the radius of the circumscribing circle.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      radius : number or instance of Basic\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.line.Segment.length, sympy.geometry.ellipse.Circle.radius\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> radius = Symbol('r')\n",
      " |      >>> rp = RegularPolygon(Point(0, 0), radius, 4)\n",
      " |      >>> rp.radius\n",
      " |      r\n",
      " |  \n",
      " |  rotation\n",
      " |      CCW angle by which the RegularPolygon is rotated\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      rotation : number or instance of Basic\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi\n",
      " |      >>> from sympy.abc import a\n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> RegularPolygon(Point(0, 0), 3, 4, pi/4).rotation\n",
      " |      pi/4\n",
      " |      \n",
      " |      Numerical rotation angles are made canonical:\n",
      " |      \n",
      " |      >>> RegularPolygon(Point(0, 0), 3, 4, a).rotation\n",
      " |      a\n",
      " |      >>> RegularPolygon(Point(0, 0), 3, 4, pi).rotation\n",
      " |      0\n",
      " |  \n",
      " |  vertices\n",
      " |      The vertices of the RegularPolygon.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      vertices : list\n",
      " |          Each vertex is a Point.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.point.Point\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point\n",
      " |      >>> rp = RegularPolygon(Point(0, 0), 5, 4)\n",
      " |      >>> rp.vertices\n",
      " |      [Point2D(5, 0), Point2D(0, 5), Point2D(-5, 0), Point2D(0, -5)]\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __annotations__ = {}\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from Polygon:\n",
      " |  \n",
      " |  __contains__(self, o)\n",
      " |      Return True if o is contained within the boundary lines of self.altitudes\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      other : GeometryEntity\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      contained in : bool\n",
      " |          The points (and sides, if applicable) are contained in self.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.entity.GeometryEntity.encloses\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Line, Segment, Point\n",
      " |      >>> p = Point(0, 0)\n",
      " |      >>> q = Point(1, 1)\n",
      " |      >>> s = Segment(p, q*2)\n",
      " |      >>> l = Line(p, q)\n",
      " |      >>> p in q\n",
      " |      False\n",
      " |      >>> p in s\n",
      " |      True\n",
      " |      >>> q*3 in s\n",
      " |      False\n",
      " |      >>> s in l\n",
      " |      True\n",
      " |  \n",
      " |  arbitrary_point(self, parameter='t')\n",
      " |      A parameterized point on the polygon.\n",
      " |      \n",
      " |      The parameter, varying from 0 to 1, assigns points to the position on\n",
      " |      the perimeter that is that fraction of the total perimeter. So the\n",
      " |      point evaluated at t=1/2 would return the point from the first vertex\n",
      " |      that is 1/2 way around the polygon.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      parameter : str, optional\n",
      " |          Default value is 't'.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      arbitrary_point : Point\n",
      " |      \n",
      " |      Raises\n",
      " |      ======\n",
      " |      \n",
      " |      ValueError\n",
      " |          When `parameter` already appears in the Polygon's definition.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.point.Point\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Polygon, Symbol\n",
      " |      >>> t = Symbol('t', real=True)\n",
      " |      >>> tri = Polygon((0, 0), (1, 0), (1, 1))\n",
      " |      >>> p = tri.arbitrary_point('t')\n",
      " |      >>> perimeter = tri.perimeter\n",
      " |      >>> s1, s2 = [s.length for s in tri.sides[:2]]\n",
      " |      >>> p.subs(t, (s1 + s2/2)/perimeter)\n",
      " |      Point2D(1, 1/2)\n",
      " |  \n",
      " |  bisectors(p, prec=None)\n",
      " |      Returns angle bisectors of a polygon. If prec is given\n",
      " |      then approximate the point defining the ray to that precision.\n",
      " |      \n",
      " |      The distance between the points defining the bisector ray is 1.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Polygon, Point\n",
      " |      >>> p = Polygon(Point(0, 0), Point(2, 0), Point(1, 1), Point(0, 3))\n",
      " |      >>> p.bisectors(2)\n",
      " |      {Point2D(0, 0): Ray2D(Point2D(0, 0), Point2D(0.71, 0.71)),\n",
      " |       Point2D(0, 3): Ray2D(Point2D(0, 3), Point2D(0.23, 2.0)),\n",
      " |       Point2D(1, 1): Ray2D(Point2D(1, 1), Point2D(0.19, 0.42)),\n",
      " |       Point2D(2, 0): Ray2D(Point2D(2, 0), Point2D(1.1, 0.38))}\n",
      " |  \n",
      " |  cut_section(self, line)\n",
      " |      Returns a tuple of two polygon segments that lie above and below\n",
      " |      the intersecting line respectively.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      line: Line object of geometry module\n",
      " |          line which cuts the Polygon. The part of the Polygon that lies\n",
      " |          above and below this line is returned.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      upper_polygon, lower_polygon: Polygon objects or None\n",
      " |          upper_polygon is the polygon that lies above the given line.\n",
      " |          lower_polygon is the polygon that lies below the given line.\n",
      " |          upper_polygon and lower polygon are ``None`` when no polygon\n",
      " |          exists above the line or below the line.\n",
      " |      \n",
      " |      Raises\n",
      " |      ======\n",
      " |      \n",
      " |      ValueError: When the line does not intersect the polygon\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Polygon, Line\n",
      " |      >>> a, b = 20, 10\n",
      " |      >>> p1, p2, p3, p4 = [(0, b), (0, 0), (a, 0), (a, b)]\n",
      " |      >>> rectangle = Polygon(p1, p2, p3, p4)\n",
      " |      >>> t = rectangle.cut_section(Line((0, 5), slope=0))\n",
      " |      >>> t\n",
      " |      (Polygon(Point2D(0, 10), Point2D(0, 5), Point2D(20, 5), Point2D(20, 10)),\n",
      " |      Polygon(Point2D(0, 5), Point2D(0, 0), Point2D(20, 0), Point2D(20, 5)))\n",
      " |      >>> upper_segment, lower_segment = t\n",
      " |      >>> upper_segment.area\n",
      " |      100\n",
      " |      >>> upper_segment.centroid\n",
      " |      Point2D(10, 15/2)\n",
      " |      >>> lower_segment.centroid\n",
      " |      Point2D(10, 5/2)\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://github.com/sympy/sympy/wiki/A-method-to-return-a-cut-section-of-any-polygon-geometry\n",
      " |  \n",
      " |  distance(self, o)\n",
      " |      Returns the shortest distance between self and o.\n",
      " |      \n",
      " |      If o is a point, then self does not need to be convex.\n",
      " |      If o is another polygon self and o must be convex.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Point, Polygon, RegularPolygon\n",
      " |      >>> p1, p2 = map(Point, [(0, 0), (7, 5)])\n",
      " |      >>> poly = Polygon(*RegularPolygon(p1, 1, 3).vertices)\n",
      " |      >>> poly.distance(p2)\n",
      " |      sqrt(61)\n",
      " |  \n",
      " |  first_moment_of_area(self, point=None)\n",
      " |      Returns the first moment of area of a two-dimensional polygon with\n",
      " |      respect to a certain point of interest.\n",
      " |      \n",
      " |      First moment of area is a measure of the distribution of the area\n",
      " |      of a polygon in relation to an axis. The first moment of area of\n",
      " |      the entire polygon about its own centroid is always zero. Therefore,\n",
      " |      here it is calculated for an area, above or below a certain point\n",
      " |      of interest, that makes up a smaller portion of the polygon. This\n",
      " |      area is bounded by the point of interest and the extreme end\n",
      " |      (top or bottom) of the polygon. The first moment for this area is\n",
      " |      is then determined about the centroidal axis of the initial polygon.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://skyciv.com/docs/tutorials/section-tutorials/calculating-the-statical-or-first-moment-of-area-of-beam-sections/?cc=BMD\n",
      " |      .. [2] https://mechanicalc.com/reference/cross-sections\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      point: Point, two-tuple of sympifyable objects, or None (default=None)\n",
      " |          point is the point above or below which the area of interest lies\n",
      " |          If ``point=None`` then the centroid acts as the point of interest.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Q_x, Q_y: number or SymPy expressions\n",
      " |          Q_x is the first moment of area about the x-axis\n",
      " |          Q_y is the first moment of area about the y-axis\n",
      " |          A negative sign indicates that the section modulus is\n",
      " |          determined for a section below (or left of) the centroidal axis\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Point, Polygon\n",
      " |      >>> a, b = 50, 10\n",
      " |      >>> p1, p2, p3, p4 = [(0, b), (0, 0), (a, 0), (a, b)]\n",
      " |      >>> p = Polygon(p1, p2, p3, p4)\n",
      " |      >>> p.first_moment_of_area()\n",
      " |      (625, 3125)\n",
      " |      >>> p.first_moment_of_area(point=Point(30, 7))\n",
      " |      (525, 3000)\n",
      " |  \n",
      " |  intersection(self, o)\n",
      " |      The intersection of polygon and geometry entity.\n",
      " |      \n",
      " |      The intersection may be empty and can contain individual Points and\n",
      " |      complete Line Segments.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      other: GeometryEntity\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      intersection : list\n",
      " |          The list of Segments and Points\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.point.Point, sympy.geometry.line.Segment\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Point, Polygon, Line\n",
      " |      >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])\n",
      " |      >>> poly1 = Polygon(p1, p2, p3, p4)\n",
      " |      >>> p5, p6, p7 = map(Point, [(3, 2), (1, -1), (0, 2)])\n",
      " |      >>> poly2 = Polygon(p5, p6, p7)\n",
      " |      >>> poly1.intersection(poly2)\n",
      " |      [Point2D(1/3, 1), Point2D(2/3, 0), Point2D(9/5, 1/5), Point2D(7/3, 1)]\n",
      " |      >>> poly1.intersection(Line(p1, p2))\n",
      " |      [Segment2D(Point2D(0, 0), Point2D(1, 0))]\n",
      " |      >>> poly1.intersection(p1)\n",
      " |      [Point2D(0, 0)]\n",
      " |  \n",
      " |  is_convex(self)\n",
      " |      Is the polygon convex?\n",
      " |      \n",
      " |      A polygon is convex if all its interior angles are less than 180\n",
      " |      degrees and there are no intersections between sides.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      is_convex : boolean\n",
      " |          True if this polygon is convex, False otherwise.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.util.convex_hull\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Point, Polygon\n",
      " |      >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])\n",
      " |      >>> poly = Polygon(p1, p2, p3, p4)\n",
      " |      >>> poly.is_convex()\n",
      " |      True\n",
      " |  \n",
      " |  parameter_value(self, other, t)\n",
      " |      Return the parameter corresponding to the given point.\n",
      " |      Evaluating an arbitrary point of the entity at this parameter\n",
      " |      value will return the given point.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Line, Point\n",
      " |      >>> from sympy.abc import t\n",
      " |      >>> a = Point(0, 0)\n",
      " |      >>> b = Point(2, 2)\n",
      " |      >>> Line(a, b).parameter_value((1, 1), t)\n",
      " |      {t: 1/2}\n",
      " |      >>> Line(a, b).arbitrary_point(t).subs(_)\n",
      " |      Point2D(1, 1)\n",
      " |  \n",
      " |  plot_interval(self, parameter='t')\n",
      " |      The plot interval for the default geometric plot of the polygon.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      parameter : str, optional\n",
      " |          Default value is 't'.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      plot_interval : list (plot interval)\n",
      " |          [parameter, lower_bound, upper_bound]\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Polygon\n",
      " |      >>> p = Polygon((0, 0), (1, 0), (1, 1))\n",
      " |      >>> p.plot_interval()\n",
      " |      [t, 0, 1]\n",
      " |  \n",
      " |  polar_second_moment_of_area(self)\n",
      " |      Returns the polar modulus of a two-dimensional polygon\n",
      " |      \n",
      " |      It is a constituent of the second moment of area, linked through\n",
      " |      the perpendicular axis theorem. While the planar second moment of\n",
      " |      area describes an object's resistance to deflection (bending) when\n",
      " |      subjected to a force applied to a plane parallel to the central\n",
      " |      axis, the polar second moment of area describes an object's\n",
      " |      resistance to deflection when subjected to a moment applied in a\n",
      " |      plane perpendicular to the object's central axis (i.e. parallel to\n",
      " |      the cross-section)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Polygon, symbols\n",
      " |      >>> a, b = symbols('a, b')\n",
      " |      >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b))\n",
      " |      >>> rectangle.polar_second_moment_of_area()\n",
      " |      a**3*b/12 + a*b**3/12\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Polar_moment_of_inertia\n",
      " |  \n",
      " |  second_moment_of_area(self, point=None)\n",
      " |      Returns the second moment and product moment of area of a two dimensional polygon.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      point : Point, two-tuple of sympifyable objects, or None(default=None)\n",
      " |          point is the point about which second moment of area is to be found.\n",
      " |          If \"point=None\" it will be calculated about the axis passing through the\n",
      " |          centroid of the polygon.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      I_xx, I_yy, I_xy : number or SymPy expression\n",
      " |                         I_xx, I_yy are second moment of area of a two dimensional polygon.\n",
      " |                         I_xy is product moment of area of a two dimensional polygon.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Polygon, symbols\n",
      " |      >>> a, b = symbols('a, b')\n",
      " |      >>> p1, p2, p3, p4, p5 = [(0, 0), (a, 0), (a, b), (0, b), (a/3, b/3)]\n",
      " |      >>> rectangle = Polygon(p1, p2, p3, p4)\n",
      " |      >>> rectangle.second_moment_of_area()\n",
      " |      (a*b**3/12, a**3*b/12, 0)\n",
      " |      >>> rectangle.second_moment_of_area(p5)\n",
      " |      (a*b**3/9, a**3*b/9, a**2*b**2/36)\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Second_moment_of_area\n",
      " |  \n",
      " |  section_modulus(self, point=None)\n",
      " |      Returns a tuple with the section modulus of a two-dimensional\n",
      " |      polygon.\n",
      " |      \n",
      " |      Section modulus is a geometric property of a polygon defined as the\n",
      " |      ratio of second moment of area to the distance of the extreme end of\n",
      " |      the polygon from the centroidal axis.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      point : Point, two-tuple of sympifyable objects, or None(default=None)\n",
      " |          point is the point at which section modulus is to be found.\n",
      " |          If \"point=None\" it will be calculated for the point farthest from the\n",
      " |          centroidal axis of the polygon.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      S_x, S_y: numbers or SymPy expressions\n",
      " |                S_x is the section modulus with respect to the x-axis\n",
      " |                S_y is the section modulus with respect to the y-axis\n",
      " |                A negative sign indicates that the section modulus is\n",
      " |                determined for a point below the centroidal axis\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Polygon, Point\n",
      " |      >>> a, b = symbols('a, b', positive=True)\n",
      " |      >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b))\n",
      " |      >>> rectangle.section_modulus()\n",
      " |      (a*b**2/6, a**2*b/6)\n",
      " |      >>> rectangle.section_modulus(Point(a/4, b/4))\n",
      " |      (-a*b**2/3, -a**2*b/3)\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Section_modulus\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from Polygon:\n",
      " |  \n",
      " |  ambient_dimension\n",
      " |      What is the dimension of the space that the object is contained in?\n",
      " |  \n",
      " |  bounds\n",
      " |      Return a tuple (xmin, ymin, xmax, ymax) representing the bounding\n",
      " |      rectangle for the geometric figure.\n",
      " |  \n",
      " |  perimeter\n",
      " |      The perimeter of the polygon.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      perimeter : number or Basic instance\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.line.Segment.length\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Point, Polygon\n",
      " |      >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])\n",
      " |      >>> poly = Polygon(p1, p2, p3, p4)\n",
      " |      >>> poly.perimeter\n",
      " |      sqrt(17) + 7\n",
      " |  \n",
      " |  sides\n",
      " |      The directed line segments that form the sides of the polygon.\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      sides : list of sides\n",
      " |          Each side is a directed Segment.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.point.Point, sympy.geometry.line.Segment\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Point, Polygon\n",
      " |      >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])\n",
      " |      >>> poly = Polygon(p1, p2, p3, p4)\n",
      " |      >>> poly.sides\n",
      " |      [Segment2D(Point2D(0, 0), Point2D(1, 0)),\n",
      " |      Segment2D(Point2D(1, 0), Point2D(5, 1)),\n",
      " |      Segment2D(Point2D(5, 1), Point2D(0, 1)), Segment2D(Point2D(0, 1), Point2D(0, 0))]\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.geometry.entity.GeometryEntity:\n",
      " |  \n",
      " |  __cmp__(self, other)\n",
      " |      Comparison of two GeometryEntities.\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |      Returns a tuple that will be passed to __new__ on unpickling.\n",
      " |  \n",
      " |  __ne__(self, o)\n",
      " |      Test inequality of two geometrical entities.\n",
      " |  \n",
      " |  __radd__(self, a)\n",
      " |      Implementation of reverse add method.\n",
      " |  \n",
      " |  __rmul__(self, a)\n",
      " |      Implementation of reverse multiplication method.\n",
      " |  \n",
      " |  __rsub__(self, a)\n",
      " |      Implementation of reverse subtraction method.\n",
      " |  \n",
      " |  __rtruediv__(self, a)\n",
      " |      Implementation of reverse division method.\n",
      " |  \n",
      " |  encloses(self, o)\n",
      " |      Return True if o is inside (not on or outside) the boundaries of self.\n",
      " |      \n",
      " |      The object will be decomposed into Points and individual Entities need\n",
      " |      only define an encloses_point method for their class.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.geometry.ellipse.Ellipse.encloses_point\n",
      " |      sympy.geometry.polygon.Polygon.encloses_point\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point, Polygon\n",
      " |      >>> t  = Polygon(*RegularPolygon(Point(0, 0), 1, 3).vertices)\n",
      " |      >>> t2 = Polygon(*RegularPolygon(Point(0, 0), 2, 3).vertices)\n",
      " |      >>> t2.encloses(t)\n",
      " |      True\n",
      " |      >>> t.encloses(t2)\n",
      " |      False\n",
      " |  \n",
      " |  equals(self, o)\n",
      " |  \n",
      " |  is_similar(self, other)\n",
      " |      Is this geometrical entity similar to another geometrical entity?\n",
      " |      \n",
      " |      Two entities are similar if a uniform scaling (enlarging or\n",
      " |      shrinking) of one of the entities will allow one to obtain the other.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      This method is not intended to be used directly but rather\n",
      " |      through the `are_similar` function found in util.py.\n",
      " |      An entity is not required to implement this method.\n",
      " |      If two different types of entities can be similar, it is only\n",
      " |      required that one of them be able to determine this.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      scale\n",
      " |  \n",
      " |  translate(self, x=0, y=0)\n",
      " |      Shift the object by adding to the x,y-coordinates the values x and y.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      rotate, scale\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import RegularPolygon, Point, Polygon\n",
      " |      >>> t = Polygon(*RegularPolygon(Point(0, 0), 1, 3).vertices)\n",
      " |      >>> t\n",
      " |      Triangle(Point2D(1, 0), Point2D(-1/2, sqrt(3)/2), Point2D(-1/2, -sqrt(3)/2))\n",
      " |      >>> t.translate(2)\n",
      " |      Triangle(Point2D(3, 0), Point2D(3/2, sqrt(3)/2), Point2D(3/2, -sqrt(3)/2))\n",
      " |      >>> t.translate(2, 2)\n",
      " |      Triangle(Point2D(3, 2), Point2D(3/2, sqrt(3)/2 + 2), Point2D(3/2, 2 - sqrt(3)/2))\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |      Return self|value.\n",
      " |  \n",
      " |  __pow__(self, exp)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __xor__(self, other)\n",
      " |  \n",
      " |  complement(self, universe)\n",
      " |      The complement of 'self' w.r.t the given universe.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(0, 1).complement(S.Reals)\n",
      " |      Union(Interval.open(-oo, 0), Interval.open(1, oo))\n",
      " |      \n",
      " |      >>> Interval(0, 1).complement(S.UniversalSet)\n",
      " |      Complement(UniversalSet, Interval(0, 1))\n",
      " |  \n",
      " |  contains(self, other)\n",
      " |      Returns a SymPy value indicating whether ``other`` is contained\n",
      " |      in ``self``: ``true`` if it is, ``false`` if it is not, else\n",
      " |      an unevaluated ``Contains`` expression (or, as in the case of\n",
      " |      ConditionSet and a union of FiniteSet/Intervals, an expression\n",
      " |      indicating the conditions for containment).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(0.5)\n",
      " |      True\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``in`` operator, but that\n",
      " |      will raise an error unless an affirmative true or false is not\n",
      " |      obtained.\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(x)\n",
      " |      (0 <= x) & (x <= 1)\n",
      " |      >>> x in Interval(0, 1)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      TypeError: did not evaluate to a bool: None\n",
      " |      \n",
      " |      The result of 'in' is a bool, not a SymPy value\n",
      " |      \n",
      " |      >>> 1 in Interval(0, 2)\n",
      " |      True\n",
      " |      >>> _ is S.true\n",
      " |      False\n",
      " |  \n",
      " |  intersect(self, other)\n",
      " |      Returns the intersection of 'self' and 'other'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      \n",
      " |      >>> Interval(1, 3).intersect(Interval(1, 2))\n",
      " |      Interval(1, 2)\n",
      " |      \n",
      " |      >>> from sympy import imageset, Lambda, symbols, S\n",
      " |      >>> n, m = symbols('n m')\n",
      " |      >>> a = imageset(Lambda(n, 2*n), S.Integers)\n",
      " |      >>> a.intersect(imageset(Lambda(m, 2*m + 1), S.Integers))\n",
      " |      EmptySet\n",
      " |  \n",
      " |  is_disjoint(self, other)\n",
      " |      Returns True if ``self`` and ``other`` are disjoint.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(1, 2))\n",
      " |      False\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(3, 4))\n",
      " |      True\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Disjoint_sets\n",
      " |  \n",
      " |  is_proper_subset(self, other)\n",
      " |      Returns True if ``self`` is a proper subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_proper_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_subset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_proper_superset(self, other)\n",
      " |      Returns True if ``self`` is a proper superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 0.5))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_subset(self, other)\n",
      " |      Returns True if ``self`` is a subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_subset(Interval(0, 1, left_open=True))\n",
      " |      False\n",
      " |  \n",
      " |  is_superset(self, other)\n",
      " |      Returns True if ``self`` is a superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_superset(Interval(0, 1))\n",
      " |      False\n",
      " |      >>> Interval(0, 1).is_superset(Interval(0, 1, left_open=True))\n",
      " |      True\n",
      " |  \n",
      " |  isdisjoint(self, other)\n",
      " |      Alias for :meth:`is_disjoint()`\n",
      " |  \n",
      " |  issubset(self, other)\n",
      " |      Alias for :meth:`is_subset()`\n",
      " |  \n",
      " |  issuperset(self, other)\n",
      " |      Alias for :meth:`is_superset()`\n",
      " |  \n",
      " |  powerset(self)\n",
      " |      Find the Power set of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import EmptySet, FiniteSet, Interval\n",
      " |      \n",
      " |      A power set of an empty set:\n",
      " |      \n",
      " |      >>> A = EmptySet\n",
      " |      >>> A.powerset()\n",
      " |      {EmptySet}\n",
      " |      \n",
      " |      A power set of a finite set:\n",
      " |      \n",
      " |      >>> A = FiniteSet(1, 2)\n",
      " |      >>> a, b, c = FiniteSet(1), FiniteSet(2), FiniteSet(1, 2)\n",
      " |      >>> A.powerset() == FiniteSet(a, b, c, EmptySet)\n",
      " |      True\n",
      " |      \n",
      " |      A power set of an interval:\n",
      " |      \n",
      " |      >>> Interval(1, 2).powerset()\n",
      " |      PowerSet(Interval(1, 2))\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Power_set\n",
      " |  \n",
      " |  symmetric_difference(self, other)\n",
      " |      Returns symmetric difference of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(1, 3).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(3, oo))\n",
      " |      >>> Interval(1, 10).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(10, oo))\n",
      " |      \n",
      " |      >>> from sympy import S, EmptySet\n",
      " |      >>> S.Reals.symmetric_difference(EmptySet)\n",
      " |      Reals\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      .. [1] https://en.wikipedia.org/wiki/Symmetric_difference\n",
      " |  \n",
      " |  union(self, other)\n",
      " |      Returns the union of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``+`` operator:\n",
      " |      \n",
      " |      >>> from sympy import Interval, FiniteSet\n",
      " |      >>> Interval(0, 1).union(Interval(2, 3))\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(0, 1) + Interval(2, 3)\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(1, 2, True, True) + FiniteSet(2, 3)\n",
      " |      Union({3}, Interval.Lopen(1, 2))\n",
      " |      \n",
      " |      Similarly it is possible to use the ``-`` operator for set differences:\n",
      " |      \n",
      " |      >>> Interval(0, 2) - Interval(0, 1)\n",
      " |      Interval.Lopen(1, 2)\n",
      " |      >>> Interval(1, 3) - FiniteSet(2)\n",
      " |      Union(Interval.Ropen(1, 2), Interval.Lopen(2, 3))\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  boundary\n",
      " |      The boundary or frontier of a set.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A point x is on the boundary of a set S if\n",
      " |      \n",
      " |      1.  x is in the closure of S.\n",
      " |          I.e. Every neighborhood of x contains a point in S.\n",
      " |      2.  x is not in the interior of S.\n",
      " |          I.e. There does not exist an open set centered on x contained\n",
      " |          entirely within S.\n",
      " |      \n",
      " |      There are the points on the outer rim of S.  If S is open then these\n",
      " |      points need not actually be contained within S.\n",
      " |      \n",
      " |      For example, the boundary of an interval is its start and end points.\n",
      " |      This is true regardless of whether or not the interval is open.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).boundary\n",
      " |      {0, 1}\n",
      " |      >>> Interval(0, 1, True, False).boundary\n",
      " |      {0, 1}\n",
      " |  \n",
      " |  closure\n",
      " |      Property method which returns the closure of a set.\n",
      " |      The closure is defined as the union of the set itself and its\n",
      " |      boundary.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S, Interval\n",
      " |      >>> S.Reals.closure\n",
      " |      Reals\n",
      " |      >>> Interval(0, 1).closure\n",
      " |      Interval(0, 1)\n",
      " |  \n",
      " |  inf\n",
      " |      The infimum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).inf\n",
      " |      0\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).inf\n",
      " |      0\n",
      " |  \n",
      " |  interior\n",
      " |      Property method which returns the interior of a set.\n",
      " |      The interior of a set S consists all points of S that do not\n",
      " |      belong to the boundary of S.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).interior\n",
      " |      Interval.open(0, 1)\n",
      " |      >>> Interval(0, 1).boundary.interior\n",
      " |      EmptySet\n",
      " |  \n",
      " |  is_EmptySet\n",
      " |  \n",
      " |  is_closed\n",
      " |      A property method to check whether a set is closed.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is closed if its complement is an open set. The closedness of a\n",
      " |      subset of the reals is determined with respect to R and its standard\n",
      " |      topology.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_closed\n",
      " |      True\n",
      " |  \n",
      " |  is_open\n",
      " |      Property method to check whether a set is open.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is open if and only if it has an empty intersection with its\n",
      " |      boundary. In particular, a subset A of the reals is open if and only\n",
      " |      if each one of its points is contained in an open interval that is a\n",
      " |      subset of A.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S\n",
      " |      >>> S.Reals.is_open\n",
      " |      True\n",
      " |      >>> S.Rationals.is_open\n",
      " |      False\n",
      " |  \n",
      " |  kind\n",
      " |      The kind of a Set\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      Any :class:`Set` will have kind :class:`SetKind` which is\n",
      " |      parametrised by the kind of the elements of the set. For example\n",
      " |      most sets are sets of numbers and will have kind\n",
      " |      ``SetKind(NumberKind)``. If elements of sets are different in kind than\n",
      " |      their kind will ``SetKind(UndefinedKind)``. See\n",
      " |      :class:`sympy.core.kind.Kind` for an explanation of the kind system.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Matrix, FiniteSet, EmptySet, ProductSet, PowerSet\n",
      " |      \n",
      " |      >>> FiniteSet(Matrix([1, 2])).kind\n",
      " |      SetKind(MatrixKind(NumberKind))\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind\n",
      " |      SetKind(NumberKind)\n",
      " |      \n",
      " |      >>> EmptySet.kind\n",
      " |      SetKind()\n",
      " |      \n",
      " |      A :class:`sympy.sets.powerset.PowerSet` is a set of sets:\n",
      " |      \n",
      " |      >>> PowerSet({1, 2, 3}).kind\n",
      " |      SetKind(SetKind(NumberKind))\n",
      " |      \n",
      " |      A :class:`ProductSet` represents the set of tuples of elements of\n",
      " |      other sets. Its kind is :class:`sympy.core.containers.TupleKind`\n",
      " |      parametrised by the kinds of the elements of those sets:\n",
      " |      \n",
      " |      >>> p = ProductSet(FiniteSet(1, 2), FiniteSet(3, 4))\n",
      " |      >>> list(p)\n",
      " |      [(1, 3), (2, 3), (1, 4), (2, 4)]\n",
      " |      >>> p.kind\n",
      " |      SetKind(TupleKind(NumberKind, NumberKind))\n",
      " |      \n",
      " |      When all elements of the set do not have same kind, the kind\n",
      " |      will be returned as ``SetKind(UndefinedKind)``:\n",
      " |      \n",
      " |      >>> FiniteSet(0, Matrix([1, 2])).kind\n",
      " |      SetKind(UndefinedKind)\n",
      " |      \n",
      " |      The kind of the elements of a set are given by the ``element_kind``\n",
      " |      attribute of ``SetKind``:\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind.element_kind\n",
      " |      NumberKind\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      NumberKind\n",
      " |      sympy.core.kind.UndefinedKind\n",
      " |      sympy.core.containers.TupleKind\n",
      " |      MatrixKind\n",
      " |      sympy.matrices.expressions.sets.MatrixSet\n",
      " |      sympy.sets.conditionset.ConditionSet\n",
      " |      Rationals\n",
      " |      Naturals\n",
      " |      Integers\n",
      " |      sympy.sets.fancysets.ImageSet\n",
      " |      sympy.sets.fancysets.Range\n",
      " |      sympy.sets.fancysets.ComplexRegion\n",
      " |      sympy.sets.powerset.PowerSet\n",
      " |      sympy.sets.sets.ProductSet\n",
      " |      sympy.sets.sets.Interval\n",
      " |      sympy.sets.sets.Union\n",
      " |      sympy.sets.sets.Intersection\n",
      " |      sympy.sets.sets.Complement\n",
      " |      sympy.sets.sets.EmptySet\n",
      " |      sympy.sets.sets.UniversalSet\n",
      " |      sympy.sets.sets.FiniteSet\n",
      " |      sympy.sets.sets.SymmetricDifference\n",
      " |      sympy.sets.sets.DisjointUnion\n",
      " |  \n",
      " |  measure\n",
      " |      The (Lebesgue) measure of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).measure\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).measure\n",
      " |      2\n",
      " |  \n",
      " |  sup\n",
      " |      The supremum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).sup\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).sup\n",
      " |      3\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  is_Complement = None\n",
      " |  \n",
      " |  is_ComplexRegion = False\n",
      " |  \n",
      " |  is_FiniteSet = False\n",
      " |  \n",
      " |  is_Intersection = None\n",
      " |  \n",
      " |  is_Interval = False\n",
      " |  \n",
      " |  is_ProductSet = False\n",
      " |  \n",
      " |  is_Union = False\n",
      " |  \n",
      " |  is_UniversalSet = None\n",
      " |  \n",
      " |  is_empty = None\n",
      " |  \n",
      " |  is_finite_set = None\n",
      " |  \n",
      " |  is_interval = False\n",
      " |  \n",
      " |  is_iterable = False\n",
      " |  \n",
      " |  is_number = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      A stub to allow Basic args (like Tuple) to be skipped when computing\n",
      " |      the content and primitive components of an expression.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.expr.Expr.as_content_primitive\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      Wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      Return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  has_xfree(self, s: 'set[Basic]')\n",
      " |      Return True if self has any of the patterns in s as a\n",
      " |      free argument, else False. This is like `Basic.has_free`\n",
      " |      but this will only report exact argument matches.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> f(x).has_xfree({f})\n",
      " |      False\n",
      " |      >>> f(x).has_xfree({f(x)})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x + 1})\n",
      " |      True\n",
      " |      >>> f(x + y + 1).has_xfree({x + 1})\n",
      " |      False\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : Expr\n",
      " |          A *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace(self, rule)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace does not differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __init_subclass__() from builtins.type\n",
      " |      This method is called when a class is subclassed.\n",
      " |      \n",
      " |      The default implementation does nothing. It may be\n",
      " |      overridden to extend subclasses.\n",
      " |  \n",
      " |  class_key() from builtins.type\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from builtins.type\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(RegularPolygon)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{\\pi}{6}\\right\\}$"
      ],
      "text/plain": [
       "{pi/6}"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(sin(2*pi/3-x)-2*sin(pi/3-x),x,Interval(0,pi/3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = Point(0, 0)\n",
    "B = Point(1,0)\n",
    "C=Point(0,1)\n",
    "D=Point(0,0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Prism}\\left(\\operatorname{Point3D}\\left(0, 0, 0\\right), \\operatorname{Point3D}\\left(1, 0, 0\\right), \\operatorname{Point3D}\\left(0, 1, 0\\right), \\operatorname{Point3D}\\left(0, 0, 1\\right), \\operatorname{Point3D}\\left(1, 0, 1\\right), \\operatorname{Point3D}\\left(0, 1, 1\\right)\\right)$"
      ],
      "text/plain": [
       "Prism(Point3D(0, 0, 0), Point3D(1, 0, 0), Point3D(0, 1, 0), Point3D(0, 0, 1), Point3D(1, 0, 1), Point3D(0, 1, 1))"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Prism(Polygon(A,B,C),D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "prism=Prism(RegularPolygon((0,0),2,3),a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3 \\sqrt{3} \\left|{a}\\right|$"
      ],
      "text/plain": [
       "3*sqrt(3)*Abs(a)"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prism.volume"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\frac{1}{2}, \\infty\\right)$"
      ],
      "text/plain": [
       "Interval(1/2, oo)"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_range((x+1)**2+x**2,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "import resource"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module resource:\n",
      "\n",
      "NAME\n",
      "    resource\n",
      "\n",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.11/library/resource.html\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "CLASSES\n",
      "    builtins.tuple(builtins.object)\n",
      "        struct_rusage\n",
      "    \n",
      "    class struct_rusage(builtins.tuple)\n",
      "     |  struct_rusage(iterable=(), /)\n",
      "     |  \n",
      "     |  struct_rusage: Result from getrusage.\n",
      "     |  \n",
      "     |  This object may be accessed either as a tuple of\n",
      "     |      (utime,stime,maxrss,ixrss,idrss,isrss,minflt,majflt,\n",
      "     |      nswap,inblock,oublock,msgsnd,msgrcv,nsignals,nvcsw,nivcsw)\n",
      "     |  or via the attributes ru_utime, ru_stime, ru_maxrss, and so on.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      struct_rusage\n",
      "     |      builtins.tuple\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  ru_idrss\n",
      "     |      unshared data size\n",
      "     |  \n",
      "     |  ru_inblock\n",
      "     |      block input operations\n",
      "     |  \n",
      "     |  ru_isrss\n",
      "     |      unshared stack size\n",
      "     |  \n",
      "     |  ru_ixrss\n",
      "     |      shared memory size\n",
      "     |  \n",
      "     |  ru_majflt\n",
      "     |      page faults requiring I/O\n",
      "     |  \n",
      "     |  ru_maxrss\n",
      "     |      max. resident set size\n",
      "     |  \n",
      "     |  ru_minflt\n",
      "     |      page faults not requiring I/O\n",
      "     |  \n",
      "     |  ru_msgrcv\n",
      "     |      IPC messages received\n",
      "     |  \n",
      "     |  ru_msgsnd\n",
      "     |      IPC messages sent\n",
      "     |  \n",
      "     |  ru_nivcsw\n",
      "     |      involuntary context switches\n",
      "     |  \n",
      "     |  ru_nsignals\n",
      "     |      signals received\n",
      "     |  \n",
      "     |  ru_nswap\n",
      "     |      number of swap outs\n",
      "     |  \n",
      "     |  ru_nvcsw\n",
      "     |      voluntary context switches\n",
      "     |  \n",
      "     |  ru_oublock\n",
      "     |      block output operations\n",
      "     |  \n",
      "     |  ru_stime\n",
      "     |      system time used\n",
      "     |  \n",
      "     |  ru_utime\n",
      "     |      user time used\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  __match_args__ = ('ru_utime', 'ru_stime', 'ru_maxrss', 'ru_ixrss', 'ru...\n",
      "     |  \n",
      "     |  n_fields = 16\n",
      "     |  \n",
      "     |  n_sequence_fields = 16\n",
      "     |  \n",
      "     |  n_unnamed_fields = 0\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.tuple:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __contains__(self, key, /)\n",
      "     |      Return key in self.\n",
      "     |  \n",
      "     |  __eq__(self, value, /)\n",
      "     |      Return self==value.\n",
      "     |  \n",
      "     |  __ge__(self, value, /)\n",
      "     |      Return self>=value.\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __getitem__(self, key, /)\n",
      "     |      Return self[key].\n",
      "     |  \n",
      "     |  __getnewargs__(self, /)\n",
      "     |  \n",
      "     |  __gt__(self, value, /)\n",
      "     |      Return self>value.\n",
      "     |  \n",
      "     |  __hash__(self, /)\n",
      "     |      Return hash(self).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __le__(self, value, /)\n",
      "     |      Return self<=value.\n",
      "     |  \n",
      "     |  __len__(self, /)\n",
      "     |      Return len(self).\n",
      "     |  \n",
      "     |  __lt__(self, value, /)\n",
      "     |      Return self<value.\n",
      "     |  \n",
      "     |  __mul__(self, value, /)\n",
      "     |      Return self*value.\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __rmul__(self, value, /)\n",
      "     |      Return value*self.\n",
      "     |  \n",
      "     |  count(self, value, /)\n",
      "     |      Return number of occurrences of value.\n",
      "     |  \n",
      "     |  index(self, value, start=0, stop=9223372036854775807, /)\n",
      "     |      Return first index of value.\n",
      "     |      \n",
      "     |      Raises ValueError if the value is not present.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Class methods inherited from builtins.tuple:\n",
      "     |  \n",
      "     |  __class_getitem__(...) from builtins.type\n",
      "     |      See PEP 585\n",
      "\n",
      "FUNCTIONS\n",
      "    getpagesize()\n",
      "    \n",
      "    getrlimit(resource, /)\n",
      "    \n",
      "    getrusage(who, /)\n",
      "    \n",
      "    prlimit(...)\n",
      "        prlimit(pid, resource, [limits])\n",
      "    \n",
      "    setrlimit(resource, limits, /)\n",
      "\n",
      "DATA\n",
      "    RLIMIT_AS = 9\n",
      "    RLIMIT_CORE = 4\n",
      "    RLIMIT_CPU = 0\n",
      "    RLIMIT_DATA = 2\n",
      "    RLIMIT_FSIZE = 1\n",
      "    RLIMIT_MEMLOCK = 8\n",
      "    RLIMIT_MSGQUEUE = 12\n",
      "    RLIMIT_NICE = 13\n",
      "    RLIMIT_NOFILE = 7\n",
      "    RLIMIT_NPROC = 6\n",
      "    RLIMIT_OFILE = 7\n",
      "    RLIMIT_RSS = 5\n",
      "    RLIMIT_RTPRIO = 14\n",
      "    RLIMIT_RTTIME = 15\n",
      "    RLIMIT_SIGPENDING = 11\n",
      "    RLIMIT_STACK = 3\n",
      "    RLIM_INFINITY = -1\n",
      "    RUSAGE_CHILDREN = -1\n",
      "    RUSAGE_SELF = 0\n",
      "    RUSAGE_THREAD = 1\n",
      "\n",
      "FILE\n",
      "    /home/huang/anaconda3/lib/python3.11/lib-dynload/resource.cpython-311-x86_64-linux-gnu.so\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(resource)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sympy.core.random as random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module sympy.core.random in sympy.core:\n",
      "\n",
      "NAME\n",
      "    sympy.core.random\n",
      "\n",
      "DESCRIPTION\n",
      "    When you need to use random numbers in SymPy library code, import from here\n",
      "    so there is only one generator working for SymPy. Imports from here should\n",
      "    behave the same as if they were being imported from Python's random module.\n",
      "    But only the routines currently used in SymPy are included here. To use others\n",
      "    import ``rng`` and access the method directly. For example, to capture the\n",
      "    current state of the generator use ``rng.getstate()``.\n",
      "    \n",
      "    There is intentionally no Random to import from here. If you want\n",
      "    to control the state of the generator, import ``seed`` and call it\n",
      "    with or without an argument to set the state.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy.core.random import random, seed\n",
      "    >>> assert random() < 1\n",
      "    >>> seed(1); a = random()\n",
      "    >>> b = random()\n",
      "    >>> seed(1); c = random()\n",
      "    >>> assert a == c\n",
      "    >>> assert a != b  # remote possibility this will fail\n",
      "\n",
      "FUNCTIONS\n",
      "    random() method of random.Random instance\n",
      "        random() -> x in the interval [0, 1).\n",
      "    \n",
      "    random_complex_number(a=2, b=-1, c=3, d=1, rational=False, tolerance=None)\n",
      "        Return a random complex number.\n",
      "        \n",
      "        To reduce chance of hitting branch cuts or anything, we guarantee\n",
      "        b <= Im z <= d, a <= Re z <= c\n",
      "        \n",
      "        When rational is True, a rational approximation to a random number\n",
      "        is obtained within specified tolerance, if any.\n",
      "    \n",
      "    seed(a=None, version=2)\n",
      "    \n",
      "    test_derivative_numerically(f, z, tol=1e-06, a=2, b=-1, c=3, d=1)\n",
      "        Test numerically that the symbolically computed derivative of f\n",
      "        with respect to z is correct.\n",
      "        \n",
      "        This routine does not test whether there are Floats present with\n",
      "        precision higher than 15 digits so if there are, your results may\n",
      "        not be what you expect due to round-off errors.\n",
      "        \n",
      "        Examples\n",
      "        ========\n",
      "        \n",
      "        >>> from sympy import sin\n",
      "        >>> from sympy.abc import x\n",
      "        >>> from sympy.core.random import test_derivative_numerically as td\n",
      "        >>> td(sin(x), x)\n",
      "        True\n",
      "    \n",
      "    verify_numerically(f, g, z=None, tol=1e-06, a=2, b=-1, c=3, d=1)\n",
      "        Test numerically that f and g agree when evaluated in the argument z.\n",
      "        \n",
      "        If z is None, all symbols will be tested. This routine does not test\n",
      "        whether there are Floats present with precision higher than 15 digits\n",
      "        so if there are, your results may not be what you expect due to round-\n",
      "        off errors.\n",
      "        \n",
      "        Examples\n",
      "        ========\n",
      "        \n",
      "        >>> from sympy import sin, cos\n",
      "        >>> from sympy.abc import x\n",
      "        >>> from sympy.core.random import verify_numerically as tn\n",
      "        >>> tn(sin(x)**2 + cos(x)**2, 1, x)\n",
      "        True\n",
      "\n",
      "DATA\n",
      "    rng = <random.Random object>\n",
      "\n",
      "FILE\n",
      "    /home/huang/anaconda3/lib/python3.11/site-packages/sympy/core/random.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(random)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.utilities.iterables import permutations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class permutations in module itertools:\n",
      "\n",
      "class permutations(builtins.object)\n",
      " |  permutations(iterable, r=None)\n",
      " |  \n",
      " |  Return successive r-length permutations of elements in the iterable.\n",
      " |  \n",
      " |  permutations(range(3), 2) --> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __next__(self, /)\n",
      " |      Implement next(self).\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      Return state information for pickling.\n",
      " |  \n",
      " |  __setstate__(...)\n",
      " |      Set state information for unpickling.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      Returns size in memory, in bytes.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(permutations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix with rows (0, 1) has determinant: -2\n",
      "Matrix with rows (1, 0) has determinant: 2\n"
     ]
    }
   ],
   "source": [
    "A = Matrix([[1, 2], [3, 4]])\n",
    "\n",
    "# 生成矩阵行的所有排列\n",
    "for perm in permutations(range(A.rows)):\n",
    "    # 根据排列创建一个新的矩阵\n",
    "    new_matrix = A[perm, :]\n",
    "    # 计算并打印这个新矩阵的行列式\n",
    "    print(f\"Matrix with rows {perm} has determinant: {det(new_matrix)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}3 & 4\\\\1 & 2\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[3, 4],\n",
       "[1, 2]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[(1,0),:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Add in module sympy.core.add:\n",
      "\n",
      "class Add(sympy.core.expr.Expr, sympy.core.operations.AssocOp)\n",
      " |  Add(*args, evaluate=None, _sympify=True)\n",
      " |  \n",
      " |  Expression representing addition operation for algebraic group.\n",
      " |  \n",
      " |  .. deprecated:: 1.7\n",
      " |  \n",
      " |     Using arguments that aren't subclasses of :class:`~.Expr` in core\n",
      " |     operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is\n",
      " |     deprecated. See :ref:`non-expr-args-deprecated` for details.\n",
      " |  \n",
      " |  Every argument of ``Add()`` must be ``Expr``. Infix operator ``+``\n",
      " |  on most scalar objects in SymPy calls this class.\n",
      " |  \n",
      " |  Another use of ``Add()`` is to represent the structure of abstract\n",
      " |  addition so that its arguments can be substituted to return different\n",
      " |  class. Refer to examples section for this.\n",
      " |  \n",
      " |  ``Add()`` evaluates the argument unless ``evaluate=False`` is passed.\n",
      " |  The evaluation logic includes:\n",
      " |  \n",
      " |  1. Flattening\n",
      " |      ``Add(x, Add(y, z))`` -> ``Add(x, y, z)``\n",
      " |  \n",
      " |  2. Identity removing\n",
      " |      ``Add(x, 0, y)`` -> ``Add(x, y)``\n",
      " |  \n",
      " |  3. Coefficient collecting by ``.as_coeff_Mul()``\n",
      " |      ``Add(x, 2*x)`` -> ``Mul(3, x)``\n",
      " |  \n",
      " |  4. Term sorting\n",
      " |      ``Add(y, x, 2)`` -> ``Add(2, x, y)``\n",
      " |  \n",
      " |  If no argument is passed, identity element 0 is returned. If single\n",
      " |  element is passed, that element is returned.\n",
      " |  \n",
      " |  Note that ``Add(*args)`` is more efficient than ``sum(args)`` because\n",
      " |  it flattens the arguments. ``sum(a, b, c, ...)`` recursively adds the\n",
      " |  arguments as ``a + (b + (c + ...))``, which has quadratic complexity.\n",
      " |  On the other hand, ``Add(a, b, c, d)`` does not assume nested\n",
      " |  structure, making the complexity linear.\n",
      " |  \n",
      " |  Since addition is group operation, every argument should have the\n",
      " |  same :obj:`sympy.core.kind.Kind()`.\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import Add, I\n",
      " |  >>> from sympy.abc import x, y\n",
      " |  >>> Add(x, 1)\n",
      " |  x + 1\n",
      " |  >>> Add(x, x)\n",
      " |  2*x\n",
      " |  >>> 2*x**2 + 3*x + I*y + 2*y + 2*x/5 + 1.0*y + 1\n",
      " |  2*x**2 + 17*x/5 + 3.0*y + I*y + 1\n",
      " |  \n",
      " |  If ``evaluate=False`` is passed, result is not evaluated.\n",
      " |  \n",
      " |  >>> Add(1, 2, evaluate=False)\n",
      " |  1 + 2\n",
      " |  >>> Add(x, x, evaluate=False)\n",
      " |  x + x\n",
      " |  \n",
      " |  ``Add()`` also represents the general structure of addition operation.\n",
      " |  \n",
      " |  >>> from sympy import MatrixSymbol\n",
      " |  >>> A,B = MatrixSymbol('A', 2,2), MatrixSymbol('B', 2,2)\n",
      " |  >>> expr = Add(x,y).subs({x:A, y:B})\n",
      " |  >>> expr\n",
      " |  A + B\n",
      " |  >>> type(expr)\n",
      " |  <class 'sympy.matrices.expressions.matadd.MatAdd'>\n",
      " |  \n",
      " |  Note that the printers do not display in args order.\n",
      " |  \n",
      " |  >>> Add(x, 1)\n",
      " |  x + 1\n",
      " |  >>> Add(x, 1).args\n",
      " |  (1, x)\n",
      " |  \n",
      " |  See Also\n",
      " |  ========\n",
      " |  \n",
      " |  MatAdd\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Add\n",
      " |      sympy.core.expr.Expr\n",
      " |      sympy.core.operations.AssocOp\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __neg__(self)\n",
      " |  \n",
      " |  as_coeff_Add(self, rational=False, deps=None)\n",
      " |      Efficiently extract the coefficient of a summation.\n",
      " |  \n",
      " |  as_coeff_add(self, *deps)\n",
      " |      Returns a tuple (coeff, args) where self is treated as an Add and coeff\n",
      " |      is the Number term and args is a tuple of all other terms.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (7 + 3*x).as_coeff_add()\n",
      " |      (7, (3*x,))\n",
      " |      >>> (7*x).as_coeff_add()\n",
      " |      (0, (7*x,))\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      Return the tuple (R, self/R) where R is the positive Rational\n",
      " |      extracted from self. If radical is True (default is False) then\n",
      " |      common radicals will be removed and included as a factor of the\n",
      " |      primitive expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> (3 + 3*sqrt(2)).as_content_primitive()\n",
      " |      (3, 1 + sqrt(2))\n",
      " |      \n",
      " |      Radical content can also be factored out of the primitive:\n",
      " |      \n",
      " |      >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)\n",
      " |      (2, sqrt(2)*(1 + 2*sqrt(5)))\n",
      " |      \n",
      " |      See docstring of Expr.as_content_primitive for more examples.\n",
      " |  \n",
      " |  as_numer_denom(self)\n",
      " |      Decomposes an expression to its numerator part and its\n",
      " |      denominator part.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x*y/z).as_numer_denom()\n",
      " |      (x*y, z)\n",
      " |      >>> (x*(y + 1)/y**7).as_numer_denom()\n",
      " |      (x*(y + 1), y**7)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.expr.Expr.as_numer_denom\n",
      " |  \n",
      " |  as_real_imag(self, deep=True, **hints)\n",
      " |      Return a tuple representing a complex number.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I\n",
      " |      >>> (7 + 9*I).as_real_imag()\n",
      " |      (7, 9)\n",
      " |      >>> ((1 + I)/(1 - I)).as_real_imag()\n",
      " |      (0, 1)\n",
      " |      >>> ((1 + 2*I)*(1 + 3*I)).as_real_imag()\n",
      " |      (-5, 5)\n",
      " |  \n",
      " |  as_two_terms(self)\n",
      " |      Return head and tail of self.\n",
      " |      \n",
      " |      This is the most efficient way to get the head and tail of an\n",
      " |      expression.\n",
      " |      \n",
      " |      - if you want only the head, use self.args[0];\n",
      " |      - if you want to process the arguments of the tail then use\n",
      " |        self.as_coef_add() which gives the head and a tuple containing\n",
      " |        the arguments of the tail when treated as an Add.\n",
      " |      - if you want the coefficient when self is treated as a Mul\n",
      " |        then use self.as_coeff_mul()[0]\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (3*x - 2*y + 5).as_two_terms()\n",
      " |      (5, 3*x - 2*y)\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |      Return True if self has -1 as a leading factor or has\n",
      " |      more literal negative signs than positive signs in a sum,\n",
      " |      otherwise False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = x - y\n",
      " |      >>> {i.could_extract_minus_sign() for i in (e, -e)}\n",
      " |      {False, True}\n",
      " |      \n",
      " |      Though the ``y - x`` is considered like ``-(x - y)``, since it\n",
      " |      is in a product without a leading factor of -1, the result is\n",
      " |      false below:\n",
      " |      \n",
      " |      >>> (x*(y - x)).could_extract_minus_sign()\n",
      " |      False\n",
      " |      \n",
      " |      To put something in canonical form wrt to sign, use `signsimp`:\n",
      " |      \n",
      " |      >>> from sympy import signsimp\n",
      " |      >>> signsimp(x*(y - x))\n",
      " |      -x*(x - y)\n",
      " |      >>> _.could_extract_minus_sign()\n",
      " |      True\n",
      " |  \n",
      " |  extract_leading_order(self, symbols, point=None)\n",
      " |      Returns the leading term and its order.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (x + 1 + 1/x**5).extract_leading_order(x)\n",
      " |      ((x**(-5), O(x**(-5))),)\n",
      " |      >>> (1 + x).extract_leading_order(x)\n",
      " |      ((1, O(1)),)\n",
      " |      >>> (x + x**2).extract_leading_order(x)\n",
      " |      ((x, O(x)),)\n",
      " |  \n",
      " |  getO(self)\n",
      " |      Returns the additive O(..) symbol if there is one, else None.\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  primitive(self)\n",
      " |      Return ``(R, self/R)`` where ``R``` is the Rational GCD of ``self```.\n",
      " |      \n",
      " |      ``R`` is collected only from the leading coefficient of each term.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> (2*x + 4*y).primitive()\n",
      " |      (2, x + 2*y)\n",
      " |      \n",
      " |      >>> (2*x/3 + 4*y/9).primitive()\n",
      " |      (2/9, 3*x + 2*y)\n",
      " |      \n",
      " |      >>> (2*x/3 + 4.2*y).primitive()\n",
      " |      (1/3, 2*x + 12.6*y)\n",
      " |      \n",
      " |      No subprocessing of term factors is performed:\n",
      " |      \n",
      " |      >>> ((2 + 2*x)*x + 2).primitive()\n",
      " |      (1, x*(2*x + 2) + 2)\n",
      " |      \n",
      " |      Recursive processing can be done with the ``as_content_primitive()``\n",
      " |      method:\n",
      " |      \n",
      " |      >>> ((2 + 2*x)*x + 2).as_content_primitive()\n",
      " |      (2, x*(x + 1) + 1)\n",
      " |      \n",
      " |      See also: primitive() function in polytools.py\n",
      " |  \n",
      " |  removeO(self)\n",
      " |      Removes the additive O(..) symbol if there is one\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  class_key() from builtins.type\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  flatten(seq) from builtins.type\n",
      " |      Takes the sequence \"seq\" of nested Adds and returns a flatten list.\n",
      " |      \n",
      " |      Returns: (commutative_part, noncommutative_part, order_symbols)\n",
      " |      \n",
      " |      Applies associativity, all terms are commutable with respect to\n",
      " |      addition.\n",
      " |      \n",
      " |      NB: the removal of 0 is already handled by AssocOp.__new__\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.mul.Mul.flatten\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  kind\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __annotations__ = {'args': typing.Tuple[sympy.core.expr.Expr, ...]}\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  identity = 0\n",
      " |  \n",
      " |  is_Add = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  __abs__(self) -> 'Expr'\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __complex__(self)\n",
      " |  \n",
      " |  __divmod__(self, other)\n",
      " |  \n",
      " |  __float__(self)\n",
      " |  \n",
      " |  __floordiv__(self, other)\n",
      " |  \n",
      " |  __format__(self, format_spec: 'str')\n",
      " |      Default object formatter.\n",
      " |  \n",
      " |  __ge__(self, other)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __gt__(self, other)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __int__(self)\n",
      " |  \n",
      " |  __le__(self, other)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lt__(self, other)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __pos__(self)\n",
      " |  \n",
      " |  __pow__(self, other, mod=None) -> 'Expr'\n",
      " |  \n",
      " |  __radd__(self, other)\n",
      " |  \n",
      " |  __rdivmod__(self, other)\n",
      " |  \n",
      " |  __rfloordiv__(self, other)\n",
      " |  \n",
      " |  __rmod__(self, other)\n",
      " |  \n",
      " |  __rmul__(self, other)\n",
      " |  \n",
      " |  __round__ = round(self, n=None)\n",
      " |  \n",
      " |  __rpow__(self, other)\n",
      " |  \n",
      " |  __rsub__(self, other)\n",
      " |  \n",
      " |  __rtruediv__(self, other)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __truediv__(self, other)\n",
      " |  \n",
      " |  __trunc__(self)\n",
      " |  \n",
      " |  adjoint(self)\n",
      " |  \n",
      " |  apart(self, x=None, **args)\n",
      " |      See the apart function in sympy.polys\n",
      " |  \n",
      " |  args_cnc(self, cset=False, warn=True, split_1=True)\n",
      " |      Return [commutative factors, non-commutative factors] of self.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      self is treated as a Mul and the ordering of the factors is maintained.\n",
      " |      If ``cset`` is True the commutative factors will be returned in a set.\n",
      " |      If there were repeated factors (as may happen with an unevaluated Mul)\n",
      " |      then an error will be raised unless it is explicitly suppressed by\n",
      " |      setting ``warn`` to False.\n",
      " |      \n",
      " |      Note: -1 is always separated from a Number unless split_1 is False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, oo\n",
      " |      >>> A, B = symbols('A B', commutative=0)\n",
      " |      >>> x, y = symbols('x y')\n",
      " |      >>> (-2*x*y).args_cnc()\n",
      " |      [[-1, 2, x, y], []]\n",
      " |      >>> (-2.5*x).args_cnc()\n",
      " |      [[-1, 2.5, x], []]\n",
      " |      >>> (-2*x*A*B*y).args_cnc()\n",
      " |      [[-1, 2, x, y], [A, B]]\n",
      " |      >>> (-2*x*A*B*y).args_cnc(split_1=False)\n",
      " |      [[-2, x, y], [A, B]]\n",
      " |      >>> (-2*x*y).args_cnc(cset=True)\n",
      " |      [{-1, 2, x, y}, []]\n",
      " |      \n",
      " |      The arg is always treated as a Mul:\n",
      " |      \n",
      " |      >>> (-2 + x + A).args_cnc()\n",
      " |      [[], [x - 2 + A]]\n",
      " |      >>> (-oo).args_cnc() # -oo is a singleton\n",
      " |      [[-1, oo], []]\n",
      " |  \n",
      " |  as_base_exp(self) -> 'tuple[Expr, Expr]'\n",
      " |  \n",
      " |  as_coeff_Mul(self, rational: 'bool' = False) -> \"tuple['Number', Expr]\"\n",
      " |      Efficiently extract the coefficient of a product.\n",
      " |  \n",
      " |  as_coeff_exponent(self, x) -> 'tuple[Expr, Expr]'\n",
      " |      ``c*x**e -> c,e`` where x can be any symbolic expression.\n",
      " |  \n",
      " |  as_coeff_mul(self, *deps, **kwargs) -> 'tuple[Expr, tuple[Expr, ...]]'\n",
      " |      Return the tuple (c, args) where self is written as a Mul, ``m``.\n",
      " |      \n",
      " |      c should be a Rational multiplied by any factors of the Mul that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other factors of m; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is a Mul or not but\n",
      " |      you want to treat self as a Mul or if you want to process the\n",
      " |      individual arguments of the tail of self as a Mul.\n",
      " |      \n",
      " |      - if you know self is a Mul and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail;\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_mul()\n",
      " |      (3, ())\n",
      " |      >>> (3*x*y).as_coeff_mul()\n",
      " |      (3, (x, y))\n",
      " |      >>> (3*x*y).as_coeff_mul(x)\n",
      " |      (3*y, (x,))\n",
      " |      >>> (3*y).as_coeff_mul(x)\n",
      " |      (3*y, ())\n",
      " |  \n",
      " |  as_coefficient(self, expr)\n",
      " |      Extracts symbolic coefficient at the given expression. In\n",
      " |      other words, this functions separates 'self' into the product\n",
      " |      of 'expr' and 'expr'-free coefficient. If such separation\n",
      " |      is not possible it will return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import E, pi, sin, I, Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> E.as_coefficient(E)\n",
      " |      1\n",
      " |      >>> (2*E).as_coefficient(E)\n",
      " |      2\n",
      " |      >>> (2*sin(E)*E).as_coefficient(E)\n",
      " |      \n",
      " |      Two terms have E in them so a sum is returned. (If one were\n",
      " |      desiring the coefficient of the term exactly matching E then\n",
      " |      the constant from the returned expression could be selected.\n",
      " |      Or, for greater precision, a method of Poly can be used to\n",
      " |      indicate the desired term from which the coefficient is\n",
      " |      desired.)\n",
      " |      \n",
      " |      >>> (2*E + x*E).as_coefficient(E)\n",
      " |      x + 2\n",
      " |      >>> _.args[0]  # just want the exact match\n",
      " |      2\n",
      " |      >>> p = Poly(2*E + x*E); p\n",
      " |      Poly(x*E + 2*E, x, E, domain='ZZ')\n",
      " |      >>> p.coeff_monomial(E)\n",
      " |      2\n",
      " |      >>> p.nth(0, 1)\n",
      " |      2\n",
      " |      \n",
      " |      Since the following cannot be written as a product containing\n",
      " |      E as a factor, None is returned. (If the coefficient ``2*x`` is\n",
      " |      desired then the ``coeff`` method should be used.)\n",
      " |      \n",
      " |      >>> (2*E*x + x).as_coefficient(E)\n",
      " |      >>> (2*E*x + x).coeff(E)\n",
      " |      2*x\n",
      " |      \n",
      " |      >>> (E*(x + 1) + x).as_coefficient(E)\n",
      " |      \n",
      " |      >>> (2*pi*I).as_coefficient(pi*I)\n",
      " |      2\n",
      " |      >>> (2*I).as_coefficient(pi*I)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      coeff: return sum of terms have a given factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  as_coefficients_dict(self, *syms)\n",
      " |      Return a dictionary mapping terms to their Rational coefficient.\n",
      " |      Since the dictionary is a defaultdict, inquiries about terms which\n",
      " |      were not present will return a coefficient of 0.\n",
      " |      \n",
      " |      If symbols ``syms`` are provided, any multiplicative terms\n",
      " |      independent of them will be considered a coefficient and a\n",
      " |      regular dictionary of syms-dependent generators as keys and\n",
      " |      their corresponding coefficients as values will be returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import a, x, y\n",
      " |      >>> (3*x + a*x + 4).as_coefficients_dict()\n",
      " |      {1: 4, x: 3, a*x: 1}\n",
      " |      >>> _[a]\n",
      " |      0\n",
      " |      >>> (3*a*x).as_coefficients_dict()\n",
      " |      {a*x: 3}\n",
      " |      >>> (3*a*x).as_coefficients_dict(x)\n",
      " |      {x: 3*a}\n",
      " |      >>> (3*a*x).as_coefficients_dict(y)\n",
      " |      {1: 3*a*x}\n",
      " |  \n",
      " |  as_expr(self, *gens)\n",
      " |      Convert a polynomial to a SymPy expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = (x**2 + x*y).as_poly(x, y)\n",
      " |      >>> f.as_expr()\n",
      " |      x**2 + x*y\n",
      " |      \n",
      " |      >>> sin(x).as_expr()\n",
      " |      sin(x)\n",
      " |  \n",
      " |  as_independent(self, *deps, **hint) -> 'tuple[Expr, Expr]'\n",
      " |      A mostly naive separation of a Mul or Add into arguments that are not\n",
      " |      are dependent on deps. To obtain as complete a separation of variables\n",
      " |      as possible, use a separation method first, e.g.:\n",
      " |      \n",
      " |      * separatevars() to change Mul, Add and Pow (including exp) into Mul\n",
      " |      * .expand(mul=True) to change Add or Mul into Add\n",
      " |      * .expand(log=True) to change log expr into an Add\n",
      " |      \n",
      " |      The only non-naive thing that is done here is to respect noncommutative\n",
      " |      ordering of variables and to always return (0, 0) for `self` of zero\n",
      " |      regardless of hints.\n",
      " |      \n",
      " |      For nonzero `self`, the returned tuple (i, d) has the\n",
      " |      following interpretation:\n",
      " |      \n",
      " |      * i will has no variable that appears in deps\n",
      " |      * d will either have terms that contain variables that are in deps, or\n",
      " |        be equal to 0 (when self is an Add) or 1 (when self is a Mul)\n",
      " |      * if self is an Add then self = i + d\n",
      " |      * if self is a Mul then self = i*d\n",
      " |      * otherwise (self, S.One) or (S.One, self) is returned.\n",
      " |      \n",
      " |      To force the expression to be treated as an Add, use the hint as_Add=True\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      -- self is an Add\n",
      " |      \n",
      " |      >>> from sympy import sin, cos, exp\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> (x + x*y).as_independent(x)\n",
      " |      (0, x*y + x)\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x)\n",
      " |      (y + z, 2*x*sin(x) + x)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x, y)\n",
      " |      (z, 2*x*sin(x) + x + y)\n",
      " |      \n",
      " |      -- self is a Mul\n",
      " |      \n",
      " |      >>> (x*sin(x)*cos(y)).as_independent(x)\n",
      " |      (cos(y), x*sin(x))\n",
      " |      \n",
      " |      non-commutative terms cannot always be separated out when self is a Mul\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False)\n",
      " |      >>> (n1 + n1*n2).as_independent(n2)\n",
      " |      (n1, n1*n2)\n",
      " |      >>> (n2*n1 + n1*n2).as_independent(n2)\n",
      " |      (0, n1*n2 + n2*n1)\n",
      " |      >>> (n1*n2*n3).as_independent(n1)\n",
      " |      (1, n1*n2*n3)\n",
      " |      >>> (n1*n2*n3).as_independent(n2)\n",
      " |      (n1, n2*n3)\n",
      " |      >>> ((x-n1)*(x-y)).as_independent(x)\n",
      " |      (1, (x - y)*(x - n1))\n",
      " |      \n",
      " |      -- self is anything else:\n",
      " |      \n",
      " |      >>> (sin(x)).as_independent(x)\n",
      " |      (1, sin(x))\n",
      " |      >>> (sin(x)).as_independent(y)\n",
      " |      (sin(x), 1)\n",
      " |      >>> exp(x+y).as_independent(x)\n",
      " |      (1, exp(x + y))\n",
      " |      \n",
      " |      -- force self to be treated as an Add:\n",
      " |      \n",
      " |      >>> (3*x).as_independent(x, as_Add=True)\n",
      " |      (0, 3*x)\n",
      " |      \n",
      " |      -- force self to be treated as a Mul:\n",
      " |      \n",
      " |      >>> (3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x + 3)\n",
      " |      >>> (-3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x - 3)\n",
      " |      \n",
      " |      Note how the below differs from the above in making the\n",
      " |      constant on the dep term positive.\n",
      " |      \n",
      " |      >>> (y*(-3+x)).as_independent(x)\n",
      " |      (y, x - 3)\n",
      " |      \n",
      " |      -- use .as_independent() for true independence testing instead\n",
      " |         of .has(). The former considers only symbols in the free\n",
      " |         symbols while the latter considers all symbols\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> I = Integral(x, (x, 1, 2))\n",
      " |      >>> I.has(x)\n",
      " |      True\n",
      " |      >>> x in I.free_symbols\n",
      " |      False\n",
      " |      >>> I.as_independent(x) == (I, 1)\n",
      " |      True\n",
      " |      >>> (I + x).as_independent(x) == (I, x)\n",
      " |      True\n",
      " |      \n",
      " |      Note: when trying to get independent terms, a separation method\n",
      " |      might need to be used first. In this case, it is important to keep\n",
      " |      track of what you send to this routine so you know how to interpret\n",
      " |      the returned values\n",
      " |      \n",
      " |      >>> from sympy import separatevars, log\n",
      " |      >>> separatevars(exp(x+y)).as_independent(x)\n",
      " |      (exp(y), exp(x))\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> separatevars(x + x*y).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).expand(mul=True).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> a, b=symbols('a b', positive=True)\n",
      " |      >>> (log(a*b).expand(log=True)).as_independent(b)\n",
      " |      (log(a), log(b))\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      separatevars\n",
      " |      expand_log\n",
      " |      sympy.core.add.Add.as_two_terms\n",
      " |      sympy.core.mul.Mul.as_two_terms\n",
      " |      as_coeff_mul\n",
      " |  \n",
      " |  as_leading_term(self, *symbols, logx=None, cdir=0)\n",
      " |      Returns the leading (nonzero) term of the series expansion of self.\n",
      " |      \n",
      " |      The _eval_as_leading_term routines are used to do this, and they must\n",
      " |      always return a non-zero value.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + x**2).as_leading_term(x)\n",
      " |      1\n",
      " |      >>> (1/x**2 + x + x**2).as_leading_term(x)\n",
      " |      x**(-2)\n",
      " |  \n",
      " |  as_ordered_factors(self, order=None)\n",
      " |      Return list of ordered factors (if Mul) else [self].\n",
      " |  \n",
      " |  as_ordered_terms(self, order=None, data=False)\n",
      " |      Transform an expression to an ordered list of terms.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, cos\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()\n",
      " |      [sin(x)**2*cos(x), sin(x)**2, 1]\n",
      " |  \n",
      " |  as_poly(self, *gens, **args)\n",
      " |      Converts ``self`` to a polynomial or returns ``None``.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly())\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly(x, y))\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + sin(y)).as_poly(x, y))\n",
      " |      None\n",
      " |  \n",
      " |  as_powers_dict(self)\n",
      " |      Return self as a dictionary of factors with each factor being\n",
      " |      treated as a power. The keys are the bases of the factors and the\n",
      " |      values, the corresponding exponents. The resulting dictionary should\n",
      " |      be used with caution if the expression is a Mul and contains non-\n",
      " |      commutative factors since the order that they appeared will be lost in\n",
      " |      the dictionary.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      as_ordered_factors: An alternative for noncommutative applications,\n",
      " |                          returning an ordered list of factors.\n",
      " |      args_cnc: Similar to as_ordered_factors, but guarantees separation\n",
      " |                of commutative and noncommutative factors.\n",
      " |  \n",
      " |  as_terms(self)\n",
      " |      Transform an expression to a list of terms.\n",
      " |  \n",
      " |  aseries(self, x=None, n=6, bound=0, hir=False)\n",
      " |      Asymptotic Series expansion of self.\n",
      " |      This is equivalent to ``self.series(x, oo, n)``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      self : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |      \n",
      " |      hir : Boolean\n",
      " |            Set this parameter to be True to produce hierarchical series.\n",
      " |            It stops the recursion at an early level and may provide nicer\n",
      " |            and more useful results.\n",
      " |      \n",
      " |      bound : Value, Integer\n",
      " |              Use the ``bound`` parameter to give limit on rewriting\n",
      " |              coefficients in its normalised form.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, exp\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> e = sin(1/x + exp(-x)) - sin(1/x)\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)\n",
      " |      \n",
      " |      >>> e.aseries(x, n=3, hir=True)\n",
      " |      -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))\n",
      " |      \n",
      " |      >>> e = exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x, bound=3) # doctest: +SKIP\n",
      " |      exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))\n",
      " |      \n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).aseries(x, n=8)\n",
      " |      1/x\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr\n",
      " |          Asymptotic series expansion of the expression.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      This algorithm is directly induced from the limit computational algorithm provided by Gruntz.\n",
      " |      It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first\n",
      " |      to look for the most rapidly varying subexpression w of a given expression f and then expands f\n",
      " |      in a series in w. Then same thing is recursively done on the leading coefficient\n",
      " |      till we get constant coefficients.\n",
      " |      \n",
      " |      If the most rapidly varying subexpression of a given expression f is f itself,\n",
      " |      the algorithm tries to find a normalised representation of the mrv set and rewrites f\n",
      " |      using this normalised representation.\n",
      " |      \n",
      " |      If the expansion contains an order term, it will be either ``O(x ** (-n))`` or ``O(w ** (-n))``\n",
      " |      where ``w`` belongs to the most rapidly varying expression of ``self``.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] Gruntz, Dominik. A new algorithm for computing asymptotic series.\n",
      " |             In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993.\n",
      " |             pp. 239-244.\n",
      " |      .. [2] Gruntz thesis - p90\n",
      " |      .. [3] https://en.wikipedia.org/wiki/Asymptotic_expansion\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      Expr.aseries: See the docstring of this function for complete details of this wrapper.\n",
      " |  \n",
      " |  cancel(self, *gens, **args)\n",
      " |      See the cancel function in sympy.polys\n",
      " |  \n",
      " |  coeff(self, x, n=1, right=False, _first=True)\n",
      " |      Returns the coefficient from the term(s) containing ``x**n``. If ``n``\n",
      " |      is zero then all terms independent of ``x`` will be returned.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      When ``x`` is noncommutative, the coefficient to the left (default) or\n",
      " |      right of ``x`` can be returned. The keyword 'right' is ignored when\n",
      " |      ``x`` is commutative.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      You can select terms that have an explicit negative in front of them:\n",
      " |      \n",
      " |      >>> (-x + 2*y).coeff(-1)\n",
      " |      x\n",
      " |      >>> (x - 2*y).coeff(-1)\n",
      " |      2*y\n",
      " |      \n",
      " |      You can select terms with no Rational coefficient:\n",
      " |      \n",
      " |      >>> (x + 2*y).coeff(1)\n",
      " |      x\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(1)\n",
      " |      0\n",
      " |      \n",
      " |      You can select terms independent of x by making n=0; in this case\n",
      " |      expr.as_independent(x)[0] is returned (and 0 will be returned instead\n",
      " |      of None):\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x, 0)\n",
      " |      3\n",
      " |      >>> eq = ((x + 1)**3).expand() + 1\n",
      " |      >>> eq\n",
      " |      x**3 + 3*x**2 + 3*x + 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 2]\n",
      " |      >>> eq -= 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 0]\n",
      " |      \n",
      " |      You can select terms that have a numerical term in front of them:\n",
      " |      \n",
      " |      >>> (-x - 2*y).coeff(2)\n",
      " |      -y\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> (x + sqrt(2)*x).coeff(sqrt(2))\n",
      " |      x\n",
      " |      \n",
      " |      The matching is exact:\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x)\n",
      " |      2\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**2)\n",
      " |      4\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**3)\n",
      " |      0\n",
      " |      >>> (z*(x + y)**2).coeff((x + y)**2)\n",
      " |      z\n",
      " |      >>> (z*(x + y)**2).coeff(x + y)\n",
      " |      0\n",
      " |      \n",
      " |      In addition, no factoring is done, so 1 + z*(1 + y) is not obtained\n",
      " |      from the following:\n",
      " |      \n",
      " |      >>> (x + z*(x + x*y)).coeff(x)\n",
      " |      1\n",
      " |      \n",
      " |      If such factoring is desired, factor_terms can be used first:\n",
      " |      \n",
      " |      >>> from sympy import factor_terms\n",
      " |      >>> factor_terms(x + z*(x + x*y)).coeff(x)\n",
      " |      z*(y + 1) + 1\n",
      " |      \n",
      " |      >>> n, m, o = symbols('n m o', commutative=False)\n",
      " |      >>> n.coeff(n)\n",
      " |      1\n",
      " |      >>> (3*n).coeff(n)\n",
      " |      3\n",
      " |      >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m\n",
      " |      1 + m\n",
      " |      >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m\n",
      " |      m\n",
      " |      \n",
      " |      If there is more than one possible coefficient 0 is returned:\n",
      " |      \n",
      " |      >>> (n*m + m*n).coeff(n)\n",
      " |      0\n",
      " |      \n",
      " |      If there is only one possible coefficient, it is returned:\n",
      " |      \n",
      " |      >>> (n*m + x*m*n).coeff(m*n)\n",
      " |      x\n",
      " |      >>> (n*m + x*m*n).coeff(m*n, right=1)\n",
      " |      1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_coefficient: separate the expression into a coefficient and factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  collect(self, syms, func=None, evaluate=True, exact=False, distribute_order_term=True)\n",
      " |      See the collect function in sympy.simplify\n",
      " |  \n",
      " |  combsimp(self)\n",
      " |      See the combsimp function in sympy.simplify\n",
      " |  \n",
      " |  compute_leading_term(self, x, logx=None)\n",
      " |      Deprecated function to compute the leading term of a series.\n",
      " |      \n",
      " |      as_leading_term is only allowed for results of .series()\n",
      " |      This is a wrapper to compute a series first.\n",
      " |  \n",
      " |  conjugate(self)\n",
      " |      Returns the complex conjugate of 'self'.\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      Wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  diff(self, *symbols, **assumptions)\n",
      " |  \n",
      " |  dir(self, x, cdir)\n",
      " |  \n",
      " |  equals(self, other, failing_expression=False)\n",
      " |      Return True if self == other, False if it does not, or None. If\n",
      " |      failing_expression is True then the expression which did not simplify\n",
      " |      to a 0 will be returned instead of None.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If ``self`` is a Number (or complex number) that is not zero, then\n",
      " |      the result is False.\n",
      " |      \n",
      " |      If ``self`` is a number and has not evaluated to zero, evalf will be\n",
      " |      used to test whether the expression evaluates to zero. If it does so\n",
      " |      and the result has significance (i.e. the precision is either -1, for\n",
      " |      a Rational result, or is greater than 1) then the evalf value will be\n",
      " |      used to return True or False.\n",
      " |  \n",
      " |  expand(self, deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)\n",
      " |      Expand an expression using hints.\n",
      " |      \n",
      " |      See the docstring of the expand() function in sympy.core.function for\n",
      " |      more information.\n",
      " |  \n",
      " |  extract_additively(self, c)\n",
      " |      Return self - c if it's possible to subtract c from self and\n",
      " |      make all matching coefficients move towards zero, else return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = 2*x + 3\n",
      " |      >>> e.extract_additively(x + 1)\n",
      " |      x + 2\n",
      " |      >>> e.extract_additively(3*x)\n",
      " |      >>> e.extract_additively(4)\n",
      " |      >>> (y*(x + 1)).extract_additively(x + 1)\n",
      " |      >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)\n",
      " |      (x + 1)*(x + 2*y) + 3\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      extract_multiplicatively\n",
      " |      coeff\n",
      " |      as_coefficient\n",
      " |  \n",
      " |  extract_branch_factor(self, allow_half=False)\n",
      " |      Try to write self as ``exp_polar(2*pi*I*n)*z`` in a nice way.\n",
      " |      Return (z, n).\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, I, pi\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> exp_polar(I*pi).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), 0)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor()\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(-pi*I).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), -1)\n",
      " |      >>> exp_polar(3*pi*I + x).extract_branch_factor()\n",
      " |      (exp_polar(x + I*pi), 1)\n",
      " |      >>> (y*exp_polar(-5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor()\n",
      " |      (y*exp_polar(2*pi*x), -1)\n",
      " |      >>> exp_polar(-I*pi/2).extract_branch_factor()\n",
      " |      (exp_polar(-I*pi/2), 0)\n",
      " |      \n",
      " |      If allow_half is True, also extract exp_polar(I*pi):\n",
      " |      \n",
      " |      >>> exp_polar(I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1/2)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 3/2)\n",
      " |      >>> exp_polar(-I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, -1/2)\n",
      " |  \n",
      " |  extract_multiplicatively(self, c)\n",
      " |      Return None if it's not possible to make self in the form\n",
      " |      c * something in a nice way, i.e. preserving the properties\n",
      " |      of arguments of self.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Rational\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**2 * y)\n",
      " |      x*y**2\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**4 * y)\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(2)\n",
      " |      x\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(3)\n",
      " |      \n",
      " |      >>> (Rational(1, 2)*x).extract_multiplicatively(3)\n",
      " |      x/6\n",
      " |  \n",
      " |  factor(self, *gens, **args)\n",
      " |      See the factor() function in sympy.polys.polytools\n",
      " |  \n",
      " |  fourier_series(self, limits=None)\n",
      " |      Compute fourier sine/cosine series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fourier_series` in sympy.series.fourier\n",
      " |      for more information.\n",
      " |  \n",
      " |  fps(self, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)\n",
      " |      Compute formal power power series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fps` function in sympy.series.formal for\n",
      " |      more information.\n",
      " |  \n",
      " |  gammasimp(self)\n",
      " |      See the gammasimp function in sympy.simplify\n",
      " |  \n",
      " |  getn(self)\n",
      " |      Returns the order of the expression.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The order is determined either from the O(...) term. If there\n",
      " |      is no O(...) term, it returns None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import O\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + O(x**2)).getn()\n",
      " |      2\n",
      " |      >>> (1 + x).getn()\n",
      " |  \n",
      " |  integrate(self, *args, **kwargs)\n",
      " |      See the integrate function in sympy.integrals\n",
      " |  \n",
      " |  invert(self, g, *gens, **args)\n",
      " |      Return the multiplicative inverse of ``self`` mod ``g``\n",
      " |      where ``self`` (and ``g``) may be symbolic expressions).\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      sympy.core.numbers.mod_inverse, sympy.polys.polytools.invert\n",
      " |  \n",
      " |  is_algebraic_expr(self, *syms)\n",
      " |      This tests whether a given expression is algebraic or not, in the\n",
      " |      given symbols, syms. When syms is not given, all free symbols\n",
      " |      will be used. The rational function does not have to be in expanded\n",
      " |      or in any kind of canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"algebraic\n",
      " |      expressions\" with symbolic exponents. This is a simple extension to the\n",
      " |      is_rational_function, including rational exponentiation.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sqrt\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> sqrt(1 + x).is_rational_function()\n",
      " |      False\n",
      " |      >>> sqrt(1 + x).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be an algebraic\n",
      " |      expression to become one.\n",
      " |      \n",
      " |      >>> from sympy import exp, factor\n",
      " |      >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)\n",
      " |      >>> a.is_algebraic_expr(x)\n",
      " |      False\n",
      " |      >>> factor(a).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      is_rational_function\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Algebraic_expression\n",
      " |  \n",
      " |  is_constant(self, *wrt, **flags)\n",
      " |      Return True if self is constant, False if not, or None if\n",
      " |      the constancy could not be determined conclusively.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If an expression has no free symbols then it is a constant. If\n",
      " |      there are free symbols it is possible that the expression is a\n",
      " |      constant, perhaps (but not necessarily) zero. To test such\n",
      " |      expressions, a few strategies are tried:\n",
      " |      \n",
      " |      1) numerical evaluation at two random points. If two such evaluations\n",
      " |      give two different values and the values have a precision greater than\n",
      " |      1 then self is not constant. If the evaluations agree or could not be\n",
      " |      obtained with any precision, no decision is made. The numerical testing\n",
      " |      is done only if ``wrt`` is different than the free symbols.\n",
      " |      \n",
      " |      2) differentiation with respect to variables in 'wrt' (or all free\n",
      " |      symbols if omitted) to see if the expression is constant or not. This\n",
      " |      will not always lead to an expression that is zero even though an\n",
      " |      expression is constant (see added test in test_expr.py). If\n",
      " |      all derivatives are zero then self is constant with respect to the\n",
      " |      given symbols.\n",
      " |      \n",
      " |      3) finding out zeros of denominator expression with free_symbols.\n",
      " |      It will not be constant if there are zeros. It gives more negative\n",
      " |      answers for expression that are not constant.\n",
      " |      \n",
      " |      If neither evaluation nor differentiation can prove the expression is\n",
      " |      constant, None is returned unless two numerical values happened to be\n",
      " |      the same and the flag ``failing_number`` is True -- in that case the\n",
      " |      numerical value will be returned.\n",
      " |      \n",
      " |      If flag simplify=False is passed, self will not be simplified;\n",
      " |      the default is True since self should be simplified before testing.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, Sum, S, pi\n",
      " |      >>> from sympy.abc import a, n, x, y\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> S(2).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, 10)).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant()\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(y)\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(n)\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(x)\n",
      " |      True\n",
      " |      >>> eq = a*cos(x)**2 + a*sin(x)**2 - a\n",
      " |      >>> eq.is_constant()\n",
      " |      True\n",
      " |      >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0\n",
      " |      True\n",
      " |      \n",
      " |      >>> (0**x).is_constant()\n",
      " |      False\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> (x**x).is_constant()\n",
      " |      False\n",
      " |      >>> one = cos(x)**2 + sin(x)**2\n",
      " |      >>> one.is_constant()\n",
      " |      True\n",
      " |      >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1\n",
      " |      True\n",
      " |  \n",
      " |  is_meromorphic(self, x, a)\n",
      " |      This tests whether an expression is meromorphic as\n",
      " |      a function of the given symbol ``x`` at the point ``a``.\n",
      " |      \n",
      " |      This method is intended as a quick test that will return\n",
      " |      None if no decision can be made without simplification or\n",
      " |      more detailed analysis.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import zoo, log, sin, sqrt\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = 1/x**2 + 1 - 2*x**3\n",
      " |      >>> f.is_meromorphic(x, 0)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      >>> g = x**log(3)\n",
      " |      >>> g.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> g.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> g.is_meromorphic(x, zoo)\n",
      " |      False\n",
      " |      \n",
      " |      >>> h = sin(1/x)*x**2\n",
      " |      >>> h.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> h.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> h.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      Multivalued functions are considered meromorphic when their\n",
      " |      branches are meromorphic. Thus most functions are meromorphic\n",
      " |      everywhere except at essential singularities and branch points.\n",
      " |      In particular, they will be meromorphic also on branch cuts\n",
      " |      except at their endpoints.\n",
      " |      \n",
      " |      >>> log(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> log(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> sqrt(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> sqrt(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |  \n",
      " |  is_polynomial(self, *syms)\n",
      " |      Return True if self is a polynomial in syms and False otherwise.\n",
      " |      \n",
      " |      This checks if self is an exact polynomial in syms.  This function\n",
      " |      returns False for expressions that are \"polynomials\" with symbolic\n",
      " |      exponents.  Thus, you should be able to apply polynomial algorithms to\n",
      " |      expressions for which this returns True, and Poly(expr, \\*syms) should\n",
      " |      work if and only if expr.is_polynomial(\\*syms) returns True. The\n",
      " |      polynomial does not have to be in expanded form.  If no symbols are\n",
      " |      given, all free symbols in the expression will be used.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', polynomial=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, Function\n",
      " |      >>> x = Symbol('x')\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial(x)\n",
      " |      True\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial()\n",
      " |      True\n",
      " |      >>> (2**x + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (2**x + 1).is_polynomial(2**x)\n",
      " |      True\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (f(x) + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (f(x) + 1).is_polynomial(f(x))\n",
      " |      True\n",
      " |      >>> (1/f(x) + 1).is_polynomial(f(x))\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', nonnegative=True, integer=True)\n",
      " |      >>> (x**n + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a polynomial to\n",
      " |      become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor, cancel\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)\n",
      " |      >>> a.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      y + 1\n",
      " |      >>> factor(a).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      >>> b = (y**2 + 2*y + 1)/(y + 1)\n",
      " |      >>> b.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> cancel(b)\n",
      " |      y + 1\n",
      " |      >>> cancel(b).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also .is_rational_function()\n",
      " |  \n",
      " |  is_rational_function(self, *syms)\n",
      " |      Test whether function is a ratio of two polynomials in the given\n",
      " |      symbols, syms. When syms is not given, all free symbols will be used.\n",
      " |      The rational function does not have to be in expanded or in any kind of\n",
      " |      canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"rational\n",
      " |      functions\" with symbolic exponents.  Thus, you should be able to call\n",
      " |      .as_numer_denom() and apply polynomial algorithms to the result for\n",
      " |      expressions for which this returns True.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', rational_function=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> (x/y).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x**2).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x/sin(y)).is_rational_function(y)\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', integer=True)\n",
      " |      >>> (x**n + 1).is_rational_function(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a rational function\n",
      " |      to become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)/y\n",
      " |      >>> a.is_rational_function(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      (y + 1)/y\n",
      " |      >>> factor(a).is_rational_function(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also is_algebraic_expr().\n",
      " |  \n",
      " |  leadterm(self, x, logx=None, cdir=0)\n",
      " |      Returns the leading term a*x**b as a tuple (a, b).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1+x+x**2).leadterm(x)\n",
      " |      (1, 0)\n",
      " |      >>> (1/x**2+x+x**2).leadterm(x)\n",
      " |      (1, -2)\n",
      " |  \n",
      " |  limit(self, x, xlim, dir='+')\n",
      " |      Compute limit x->xlim.\n",
      " |  \n",
      " |  lseries(self, x=None, x0=0, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper for series yielding an iterator of the terms of the series.\n",
      " |      \n",
      " |      Note: an infinite series will yield an infinite iterator. The following,\n",
      " |      for exaxmple, will never terminate. It will just keep printing terms\n",
      " |      of the sin(x) series::\n",
      " |      \n",
      " |        for term in sin(x).lseries(x):\n",
      " |            print term\n",
      " |      \n",
      " |      The advantage of lseries() over nseries() is that many times you are\n",
      " |      just interested in the next term in the series (i.e. the first term for\n",
      " |      example), but you do not know how many you should ask for in nseries()\n",
      " |      using the \"n\" parameter.\n",
      " |      \n",
      " |      See also nseries().\n",
      " |  \n",
      " |  normal(self)\n",
      " |      Return the expression as a fraction.\n",
      " |      \n",
      " |      expression -> a/b\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_numer_denom: return ``(a, b)`` instead of ``a/b``\n",
      " |  \n",
      " |  nseries(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper to _eval_nseries if assumptions allow, else to series.\n",
      " |      \n",
      " |      If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is\n",
      " |      called. This calculates \"n\" terms in the innermost expressions and\n",
      " |      then builds up the final series just by \"cross-multiplying\" everything\n",
      " |      out.\n",
      " |      \n",
      " |      The optional ``logx`` parameter can be used to replace any log(x) in the\n",
      " |      returned series with a symbolic value to avoid evaluating log(x) at 0. A\n",
      " |      symbol to use in place of log(x) should be provided.\n",
      " |      \n",
      " |      Advantage -- it's fast, because we do not have to determine how many\n",
      " |      terms we need to calculate in advance.\n",
      " |      \n",
      " |      Disadvantage -- you may end up with less terms than you may have\n",
      " |      expected, but the O(x**n) term appended will always be correct and\n",
      " |      so the result, though perhaps shorter, will also be correct.\n",
      " |      \n",
      " |      If any of those assumptions is not met, this is treated like a\n",
      " |      wrapper to series which will try harder to return the correct\n",
      " |      number of terms.\n",
      " |      \n",
      " |      See also lseries().\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, log, Symbol\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> sin(x).nseries(x, 0, 6)\n",
      " |      x - x**3/6 + x**5/120 + O(x**6)\n",
      " |      >>> log(x+1).nseries(x, 0, 5)\n",
      " |      x - x**2/2 + x**3/3 - x**4/4 + O(x**5)\n",
      " |      \n",
      " |      Handling of the ``logx`` parameter --- in the following example the\n",
      " |      expansion fails since ``sin`` does not have an asymptotic expansion\n",
      " |      at -oo (the limit of log(x) as x approaches 0):\n",
      " |      \n",
      " |      >>> e = sin(log(x))\n",
      " |      >>> e.nseries(x, 0, 6)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      PoleError: ...\n",
      " |      ...\n",
      " |      >>> logx = Symbol('logx')\n",
      " |      >>> e.nseries(x, 0, 6, logx=logx)\n",
      " |      sin(logx)\n",
      " |      \n",
      " |      In the following example, the expansion works but only returns self\n",
      " |      unless the ``logx`` parameter is used:\n",
      " |      \n",
      " |      >>> e = x**y\n",
      " |      >>> e.nseries(x, 0, 2)\n",
      " |      x**y\n",
      " |      >>> e.nseries(x, 0, 2, logx=logx)\n",
      " |      exp(logx*y)\n",
      " |  \n",
      " |  nsimplify(self, constants=(), tolerance=None, full=False)\n",
      " |      See the nsimplify function in sympy.simplify\n",
      " |  \n",
      " |  powsimp(self, *args, **kwargs)\n",
      " |      See the powsimp function in sympy.simplify\n",
      " |  \n",
      " |  radsimp(self, **kwargs)\n",
      " |      See the radsimp function in sympy.simplify\n",
      " |  \n",
      " |  ratsimp(self)\n",
      " |      See the ratsimp function in sympy.simplify\n",
      " |  \n",
      " |  round(self, n=None)\n",
      " |      Return x rounded to the given decimal place.\n",
      " |      \n",
      " |      If a complex number would results, apply round to the real\n",
      " |      and imaginary components of the number.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, E, I, S, Number\n",
      " |      >>> pi.round()\n",
      " |      3\n",
      " |      >>> pi.round(2)\n",
      " |      3.14\n",
      " |      >>> (2*pi + E*I).round()\n",
      " |      6 + 3*I\n",
      " |      \n",
      " |      The round method has a chopping effect:\n",
      " |      \n",
      " |      >>> (2*pi + I/10).round()\n",
      " |      6\n",
      " |      >>> (pi/10 + 2*I).round()\n",
      " |      2*I\n",
      " |      >>> (pi/10 + E*I).round(2)\n",
      " |      0.31 + 2.72*I\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      The Python ``round`` function uses the SymPy ``round`` method so it\n",
      " |      will always return a SymPy number (not a Python float or int):\n",
      " |      \n",
      " |      >>> isinstance(round(S(123), -2), Number)\n",
      " |      True\n",
      " |  \n",
      " |  separate(self, deep=False, force=False)\n",
      " |      See the separate function in sympy.simplify\n",
      " |  \n",
      " |  series(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Series expansion of \"self\" around ``x = x0`` yielding either terms of\n",
      " |      the series one by one (the lazy series given when n=None), else\n",
      " |      all the terms at once when n != None.\n",
      " |      \n",
      " |      Returns the series expansion of \"self\" around the point ``x = x0``\n",
      " |      with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6).\n",
      " |      \n",
      " |      If ``x=None`` and ``self`` is univariate, the univariate symbol will\n",
      " |      be supplied, otherwise an error will be raised.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      expr : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      x0 : Value\n",
      " |           The value around which ``x`` is calculated. Can be any value\n",
      " |           from ``-oo`` to ``oo``.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |      \n",
      " |      dir : String, optional\n",
      " |            The series-expansion can be bi-directional. If ``dir=\"+\"``,\n",
      " |            then (x->x0+). If ``dir=\"-\", then (x->x0-). For infinite\n",
      " |            ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined\n",
      " |            from the direction of the infinity (i.e., ``dir=\"-\"`` for\n",
      " |            ``oo``).\n",
      " |      \n",
      " |      logx : optional\n",
      " |             It is used to replace any log(x) in the returned series with a\n",
      " |             symbolic value rather than evaluating the actual value.\n",
      " |      \n",
      " |      cdir : optional\n",
      " |             It stands for complex direction, and indicates the direction\n",
      " |             from which the expansion needs to be evaluated.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, exp, tan\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> cos(x).series()\n",
      " |      1 - x**2/2 + x**4/24 + O(x**6)\n",
      " |      >>> cos(x).series(n=4)\n",
      " |      1 - x**2/2 + O(x**4)\n",
      " |      >>> cos(x).series(x, x0=1, n=2)\n",
      " |      cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1))\n",
      " |      >>> e = cos(x + exp(y))\n",
      " |      >>> e.series(y, n=2)\n",
      " |      cos(x + 1) - y*sin(x + 1) + O(y**2)\n",
      " |      >>> e.series(x, n=2)\n",
      " |      cos(exp(y)) - x*sin(exp(y)) + O(x**2)\n",
      " |      \n",
      " |      If ``n=None`` then a generator of the series terms will be returned.\n",
      " |      \n",
      " |      >>> term=cos(x).series(n=None)\n",
      " |      >>> [next(term) for i in range(2)]\n",
      " |      [1, -x**2/2]\n",
      " |      \n",
      " |      For ``dir=+`` (default) the series is calculated from the right and\n",
      " |      for ``dir=-`` the series from the left. For smooth functions this\n",
      " |      flag will not alter the results.\n",
      " |      \n",
      " |      >>> abs(x).series(dir=\"+\")\n",
      " |      x\n",
      " |      >>> abs(x).series(dir=\"-\")\n",
      " |      -x\n",
      " |      >>> f = tan(x)\n",
      " |      >>> f.series(x, 2, 6, \"+\")\n",
      " |      tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +\n",
      " |      (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +\n",
      " |      5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +\n",
      " |      2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))\n",
      " |      \n",
      " |      >>> f.series(x, 2, 3, \"-\")\n",
      " |      tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))\n",
      " |      + O((x - 2)**3, (x, 2))\n",
      " |      \n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).series(x, n=8)\n",
      " |      1/x\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr : Expression\n",
      " |          Series expansion of the expression about x0\n",
      " |      \n",
      " |      Raises\n",
      " |      ======\n",
      " |      \n",
      " |      TypeError\n",
      " |          If \"n\" and \"x0\" are infinity objects\n",
      " |      \n",
      " |      PoleError\n",
      " |          If \"x0\" is an infinity object\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  taylor_term(self, n, x, *previous_terms)\n",
      " |      General method for the taylor term.\n",
      " |      \n",
      " |      This method is slow, because it differentiates n-times. Subclasses can\n",
      " |      redefine it to make it faster by using the \"previous_terms\".\n",
      " |  \n",
      " |  together(self, *args, **kwargs)\n",
      " |      See the together function in sympy.polys\n",
      " |  \n",
      " |  transpose(self)\n",
      " |  \n",
      " |  trigsimp(self, **args)\n",
      " |      See the trigsimp function in sympy.simplify\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |      Like ``free_symbols``, but returns the free symbols only if\n",
      " |      they are contained in an expression node.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (x + y).expr_free_symbols # doctest: +SKIP\n",
      " |      {x, y}\n",
      " |      \n",
      " |      If the expression is contained in a non-expression object, do not return\n",
      " |      the free symbols. Compare:\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> t = Tuple(x + y)\n",
      " |      >>> t.expr_free_symbols # doctest: +SKIP\n",
      " |      set()\n",
      " |      >>> t.free_symbols\n",
      " |      {x, y}\n",
      " |  \n",
      " |  is_number\n",
      " |      Returns True if ``self`` has no free symbols and no\n",
      " |      undefined functions (AppliedUndef, to be precise). It will be\n",
      " |      faster than ``if not self.free_symbols``, however, since\n",
      " |      ``is_number`` will fail as soon as it hits a free symbol\n",
      " |      or undefined function.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Function, Integral, cos, sin, pi\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> f = Function('f')\n",
      " |      \n",
      " |      >>> x.is_number\n",
      " |      False\n",
      " |      >>> f(1).is_number\n",
      " |      False\n",
      " |      >>> (2*x).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, x)).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, (x, 1, 2))).is_number\n",
      " |      True\n",
      " |      \n",
      " |      Not all numbers are Numbers in the SymPy sense:\n",
      " |      \n",
      " |      >>> pi.is_number, pi.is_Number\n",
      " |      (True, False)\n",
      " |      \n",
      " |      If something is a number it should evaluate to a number with\n",
      " |      real and imaginary parts that are Numbers; the result may not\n",
      " |      be comparable, however, since the real and/or imaginary part\n",
      " |      of the result may not have precision.\n",
      " |      \n",
      " |      >>> cos(1).is_number and cos(1).is_comparable\n",
      " |      True\n",
      " |      \n",
      " |      >>> z = cos(1)**2 + sin(1)**2 - 1\n",
      " |      >>> z.is_number\n",
      " |      True\n",
      " |      >>> z.is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.basic.Basic.is_comparable\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  is_scalar = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.operations.AssocOp:\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.operations.AssocOp:\n",
      " |  \n",
      " |  make_args(expr) from builtins.type\n",
      " |      Return a sequence of elements `args` such that cls(*args) == expr\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, Mul, Add\n",
      " |      >>> x, y = map(Symbol, 'xy')\n",
      " |      \n",
      " |      >>> Mul.make_args(x*y)\n",
      " |      (x, y)\n",
      " |      >>> Add.make_args(x*y)\n",
      " |      (x*y,)\n",
      " |      >>> set(Add.make_args(x*y + y)) == set([y, x*y])\n",
      " |      True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from sympy.core.operations.AssocOp:\n",
      " |  \n",
      " |  __new__(cls, *args, evaluate=None, _sympify=True)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from sympy.core.operations.AssocOp:\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from https://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      Return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  has_xfree(self, s: 'set[Basic]')\n",
      " |      Return True if self has any of the patterns in s as a\n",
      " |      free argument, else False. This is like `Basic.has_free`\n",
      " |      but this will only report exact argument matches.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> f(x).has_xfree({f})\n",
      " |      False\n",
      " |      >>> f(x).has_xfree({f(x)})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x + 1})\n",
      " |      True\n",
      " |      >>> f(x + y + 1).has_xfree({x + 1})\n",
      " |      False\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : Expr\n",
      " |          A *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace(self, rule)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace does not differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __init_subclass__() from builtins.type\n",
      " |      This method is called when a class is subclassed.\n",
      " |      \n",
      " |      The default implementation does nothing. It may be\n",
      " |      overridden to extend subclasses.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from builtins.type\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Add)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\cdot 3 x$"
      ],
      "text/plain": [
       "2*3*x"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Mul(2,3,x,evaluate=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=A[(1,0),:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}3 & 4\\\\1 & 2\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[3, 4],\n",
       "[1, 2]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "perms= permutations(range(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(2, 4)]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(A[0,:],A[1,:]))[1::]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3$"
      ],
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[*(1,0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Matrix([[1,2,3],[2,3,4],[3,4,5]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3\\\\2 & 3 & 4\\\\3 & 4 & 5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1, 2, 3],\n",
       "[2, 3, 4],\n",
       "[3, 4, 5]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Matrix([[1,2,3],[2,3,4],[3,4,5]])\n",
    "answer=[]\n",
    "n=3\n",
    "perms= permutations(range(n))\n",
    "for perm in perms:\n",
    "    li=list(zip(range(n),perm))\n",
    "    terms=[A[*p] for p in li]\n",
    "    term=Mul(*terms,evaluate=False)\n",
    "    answer.append(term)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1*3*5, 1*4*4, 2*2*5, 2*4*3, 3*2*4, 3*3*3]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B,C,a,b,c=symbols(\"A,B,C,a,b,c\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport basic_package.vec\n",
    "from basic_package.vec import Vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=Vec(\"a\",[0,2,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=Vec(\"b\",[0,2,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 5$"
      ],
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b*a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle as$"
      ],
      "text/plain": [
       "as"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3*a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0\\\\8\\\\4\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0],\n",
       "[8],\n",
       "[4]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "hyper=Hyperbola(Point(0,0),2,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2}}{4} - y^{2} - 1$"
      ],
      "text/plain": [
       "x**2/4 - y**2 - 1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hyper.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(y-k*(x-3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - k x + 3 k + y$"
      ],
      "text/plain": [
       "-k*x + 3*k + y"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 24 k^{2} x + x^{2} \\cdot \\left(2 k - 1\\right) \\left(2 k + 1\\right) + 4 \\cdot \\left(9 k^{2} + 1\\right)$"
      ],
      "text/plain": [
       "-24*k**2*x + x**2*(2*k - 1)*(2*k + 1) + 4*(9*k**2 + 1)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(l,hyper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b=symbols(\"a,b\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "hyper=Hyperbola(Point(0,0),a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -1 - \\frac{y^{2}}{b^{2}} + \\frac{x^{2}}{a^{2}}$"
      ],
      "text/plain": [
       "-1 - y**2/b**2 + x**2/a**2"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hyper.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "F1,F2=hyper.foci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(- \\sqrt{a^{2} + b^{2}}, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(-sqrt(a**2 + b**2), 0)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "O=Point(0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "e=Ellipse(O,sqrt(12),3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(x+2*y-18)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 y^{2} - 27 y + 117$"
      ],
      "text/plain": [
       "2*y**2 - 27*y + 117"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(l,e,first=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "q=QuadraticFunction(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -207$"
      ],
      "text/plain": [
       "-207"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "ellip=Ellipse(O,a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "M=Point(1,3/S(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(1, \\frac{3}{2}\\right)$"
      ],
      "text/plain": [
       "Point2D(1, 3/2)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "F=ellip.foci[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\sqrt{a^{2} - b^{2}}, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(sqrt(a**2 - b**2), 0)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{x: 1, y: 3/2}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(zip((x,y),M))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( -2, \\  - \\sqrt{3}\\right), \\left( -2, \\  \\sqrt{3}\\right), \\left( - \\frac{1}{2}, \\  - \\frac{\\sqrt{3} i}{2}\\right), \\left( - \\frac{1}{2}, \\  \\frac{\\sqrt{3} i}{2}\\right), \\left( \\frac{1}{2}, \\  - \\frac{\\sqrt{3} i}{2}\\right), \\left( \\frac{1}{2}, \\  \\frac{\\sqrt{3} i}{2}\\right), \\left( 2, \\  - \\sqrt{3}\\right), \\left( 2, \\  \\sqrt{3}\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(-2, -sqrt(3)), (-2, sqrt(3)), (-1/2, -sqrt(3)*I/2), (-1/2, sqrt(3)*I/2), (1/2, -sqrt(3)*I/2), (1/2, sqrt(3)*I/2), (2, -sqrt(3)), (2, sqrt(3))}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nonlinsolve([F.x-M.x,ellip.equation(x,y).subs(data)],[a,b])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(-2, sqrt(3)),\n",
       " (2, sqrt(3)),\n",
       " (-2, -sqrt(3)),\n",
       " (2, -sqrt(3)),\n",
       " (-1/2, -sqrt(3)*I/2),\n",
       " (-1/2, sqrt(3)*I/2),\n",
       " (1/2, -sqrt(3)*I/2),\n",
       " (1/2, sqrt(3)*I/2)]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=_[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left( 2, \\  \\sqrt{3}\\right)$"
      ],
      "text/plain": [
       "(2, sqrt(3))"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=Point(4,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=Ellipse(O,*answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "F=c.foci[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(1, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(1, 0)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "k =symbols(\"k\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(P,slope=k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - k x + 4 k + y$"
      ],
      "text/plain": [
       "-k*x + 4*k + y"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B=Intersection(l,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{- \\frac{6 k \\sqrt{- \\left(2 k - 1\\right) \\left(2 k + 1\\right)}}{4 k^{2} + 3} + 4 k - \\frac{12 k}{4 k^{2} + 3}}{k}, - \\frac{6 k \\sqrt{- \\left(2 k - 1\\right) \\left(2 k + 1\\right)}}{4 k^{2} + 3} - \\frac{12 k}{4 k^{2} + 3}\\right)$"
      ],
      "text/plain": [
       "Point2D((-6*k*sqrt(-(2*k - 1)*(2*k + 1))/(4*k**2 + 3) + 4*k - 12*k/(4*k**2 + 3))/k, -6*k*sqrt(-(2*k - 1)*(2*k + 1))/(4*k**2 + 3) - 12*k/(4*k**2 + 3))"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{\\frac{6 k \\sqrt{- \\left(2 k - 1\\right) \\left(2 k + 1\\right)}}{4 k^{2} + 3} + 4 k - \\frac{12 k}{4 k^{2} + 3}}{k}, \\frac{6 k \\sqrt{- \\left(2 k - 1\\right) \\left(2 k + 1\\right)}}{4 k^{2} + 3} - \\frac{12 k}{4 k^{2} + 3}\\right)$"
      ],
      "text/plain": [
       "Point2D((6*k*sqrt(-(2*k - 1)*(2*k + 1))/(4*k**2 + 3) + 4*k - 12*k/(4*k**2 + 3))/k, 6*k*sqrt(-(2*k - 1)*(2*k + 1))/(4*k**2 + 3) - 12*k/(4*k**2 + 3))"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "N=(F+P)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{5}{2}, 0\\right)$"
      ],
      "text/plain": [
       "Point2D(5/2, 0)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "Q,=Intersection(Line(M,F),Line(N,B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(1, \\frac{6 k \\left(2 - \\sqrt{1 - 4 k^{2}}\\right)}{4 k^{2} + 4 \\sqrt{1 - 4 k^{2}} - 5}\\right)$"
      ],
      "text/plain": [
       "Point2D(1, 6*k*(2 - sqrt(1 - 4*k**2))/(4*k**2 + 4*sqrt(1 - 4*k**2) - 5))"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Line(A,Q).slope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 32 k^{2} x + x^{2} \\cdot \\left(4 k^{2} + 3\\right) + 4 \\cdot \\left(16 k^{2} - 3\\right)$"
      ],
      "text/plain": [
       "-32*k**2*x + x**2*(4*k**2 + 3) + 4*(16*k**2 - 3)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(l,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "q=QuadraticFunction(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1024 k^{4} - \\left(16 k^{2} + 12\\right) \\left(64 k^{2} - 12\\right)$"
      ],
      "text/plain": [
       "1024*k**4 - (16*k**2 + 12)*(64*k**2 - 12)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 144 - 576 k^{2}$"
      ],
      "text/plain": [
       "144 - 576*k**2"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(- \\frac{1}{2}, \\frac{1}{2}\\right)$"
      ],
      "text/plain": [
       "Interval.open(-1/2, 1/2)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_>0,k,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class fibonacci in module sympy.functions.combinatorial.numbers:\n",
      "\n",
      "class fibonacci(sympy.core.function.Function)\n",
      " |  fibonacci(n, sym=None)\n",
      " |  \n",
      " |  Fibonacci numbers / Fibonacci polynomials\n",
      " |  \n",
      " |  The Fibonacci numbers are the integer sequence defined by the\n",
      " |  initial terms `F_0 = 0`, `F_1 = 1` and the two-term recurrence\n",
      " |  relation `F_n = F_{n-1} + F_{n-2}`.  This definition\n",
      " |  extended to arbitrary real and complex arguments using\n",
      " |  the formula\n",
      " |  \n",
      " |  .. math :: F_z = \\frac{\\phi^z - \\cos(\\pi z) \\phi^{-z}}{\\sqrt 5}\n",
      " |  \n",
      " |  The Fibonacci polynomials are defined by `F_1(x) = 1`,\n",
      " |  `F_2(x) = x`, and `F_n(x) = x*F_{n-1}(x) + F_{n-2}(x)` for `n > 2`.\n",
      " |  For all positive integers `n`, `F_n(1) = F_n`.\n",
      " |  \n",
      " |  * ``fibonacci(n)`` gives the `n^{th}` Fibonacci number, `F_n`\n",
      " |  * ``fibonacci(n, x)`` gives the `n^{th}` Fibonacci polynomial in `x`, `F_n(x)`\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import fibonacci, Symbol\n",
      " |  \n",
      " |  >>> [fibonacci(x) for x in range(11)]\n",
      " |  [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n",
      " |  >>> fibonacci(5, Symbol('t'))\n",
      " |  t**4 + 3*t**2 + 1\n",
      " |  \n",
      " |  See Also\n",
      " |  ========\n",
      " |  \n",
      " |  bell, bernoulli, catalan, euler, harmonic, lucas, genocchi, partition, tribonacci\n",
      " |  \n",
      " |  References\n",
      " |  ==========\n",
      " |  \n",
      " |  .. [1] https://en.wikipedia.org/wiki/Fibonacci_number\n",
      " |  .. [2] https://mathworld.wolfram.com/FibonacciNumber.html\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      fibonacci\n",
      " |      sympy.core.function.Function\n",
      " |      sympy.core.function.Application\n",
      " |      sympy.core.expr.Expr\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  eval(n, sym=None) from sympy.core.function.FunctionClass\n",
      " |      Returns a canonical form of cls applied to arguments args.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The ``eval()`` method is called when the class ``cls`` is about to be\n",
      " |      instantiated and it should return either some simplified instance\n",
      " |      (possible of some other class), or if the class ``cls`` should be\n",
      " |      unmodified, return None.\n",
      " |      \n",
      " |      Examples of ``eval()`` for the function \"sign\"\n",
      " |      \n",
      " |      .. code-block:: python\n",
      " |      \n",
      " |          @classmethod\n",
      " |          def eval(cls, arg):\n",
      " |              if arg is S.NaN:\n",
      " |                  return S.NaN\n",
      " |              if arg.is_zero: return S.Zero\n",
      " |              if arg.is_positive: return S.One\n",
      " |              if arg.is_negative: return S.NegativeOne\n",
      " |              if isinstance(arg, Mul):\n",
      " |                  coeff, terms = arg.as_coeff_Mul(rational=True)\n",
      " |                  if coeff is not S.One:\n",
      " |                      return cls(coeff) * cls(terms)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __annotations__ = {}\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  as_base_exp(self)\n",
      " |      Returns the method as the 2-tuple (base, exponent).\n",
      " |  \n",
      " |  fdiff(self, argindex=1)\n",
      " |      Returns the first derivative of the function.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  class_key() from sympy.core.function.FunctionClass\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  is_singular(a) from sympy.core.function.FunctionClass\n",
      " |      Tests whether the argument is an essential singularity\n",
      " |      or a branch point, or the functions is non-holomorphic.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  __new__(cls, *args, **options)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  is_Function = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  __abs__(self) -> 'Expr'\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __complex__(self)\n",
      " |  \n",
      " |  __divmod__(self, other)\n",
      " |  \n",
      " |  __float__(self)\n",
      " |  \n",
      " |  __floordiv__(self, other)\n",
      " |  \n",
      " |  __format__(self, format_spec: 'str')\n",
      " |      Default object formatter.\n",
      " |  \n",
      " |  __ge__(self, other)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __gt__(self, other)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __int__(self)\n",
      " |  \n",
      " |  __le__(self, other)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lt__(self, other)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __neg__(self)\n",
      " |  \n",
      " |  __pos__(self)\n",
      " |  \n",
      " |  __pow__(self, other, mod=None) -> 'Expr'\n",
      " |  \n",
      " |  __radd__(self, other)\n",
      " |  \n",
      " |  __rdivmod__(self, other)\n",
      " |  \n",
      " |  __rfloordiv__(self, other)\n",
      " |  \n",
      " |  __rmod__(self, other)\n",
      " |  \n",
      " |  __rmul__(self, other)\n",
      " |  \n",
      " |  __round__ = round(self, n=None)\n",
      " |  \n",
      " |  __rpow__(self, other)\n",
      " |  \n",
      " |  __rsub__(self, other)\n",
      " |  \n",
      " |  __rtruediv__(self, other)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __truediv__(self, other)\n",
      " |  \n",
      " |  __trunc__(self)\n",
      " |  \n",
      " |  adjoint(self)\n",
      " |  \n",
      " |  apart(self, x=None, **args)\n",
      " |      See the apart function in sympy.polys\n",
      " |  \n",
      " |  args_cnc(self, cset=False, warn=True, split_1=True)\n",
      " |      Return [commutative factors, non-commutative factors] of self.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      self is treated as a Mul and the ordering of the factors is maintained.\n",
      " |      If ``cset`` is True the commutative factors will be returned in a set.\n",
      " |      If there were repeated factors (as may happen with an unevaluated Mul)\n",
      " |      then an error will be raised unless it is explicitly suppressed by\n",
      " |      setting ``warn`` to False.\n",
      " |      \n",
      " |      Note: -1 is always separated from a Number unless split_1 is False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, oo\n",
      " |      >>> A, B = symbols('A B', commutative=0)\n",
      " |      >>> x, y = symbols('x y')\n",
      " |      >>> (-2*x*y).args_cnc()\n",
      " |      [[-1, 2, x, y], []]\n",
      " |      >>> (-2.5*x).args_cnc()\n",
      " |      [[-1, 2.5, x], []]\n",
      " |      >>> (-2*x*A*B*y).args_cnc()\n",
      " |      [[-1, 2, x, y], [A, B]]\n",
      " |      >>> (-2*x*A*B*y).args_cnc(split_1=False)\n",
      " |      [[-2, x, y], [A, B]]\n",
      " |      >>> (-2*x*y).args_cnc(cset=True)\n",
      " |      [{-1, 2, x, y}, []]\n",
      " |      \n",
      " |      The arg is always treated as a Mul:\n",
      " |      \n",
      " |      >>> (-2 + x + A).args_cnc()\n",
      " |      [[], [x - 2 + A]]\n",
      " |      >>> (-oo).args_cnc() # -oo is a singleton\n",
      " |      [[-1, oo], []]\n",
      " |  \n",
      " |  as_coeff_Add(self, rational=False) -> \"tuple['Number', Expr]\"\n",
      " |      Efficiently extract the coefficient of a summation.\n",
      " |  \n",
      " |  as_coeff_Mul(self, rational: 'bool' = False) -> \"tuple['Number', Expr]\"\n",
      " |      Efficiently extract the coefficient of a product.\n",
      " |  \n",
      " |  as_coeff_add(self, *deps) -> 'tuple[Expr, tuple[Expr, ...]]'\n",
      " |      Return the tuple (c, args) where self is written as an Add, ``a``.\n",
      " |      \n",
      " |      c should be a Rational added to any terms of the Add that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other terms of ``a``; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is an Add or not but\n",
      " |      you want to treat self as an Add or if you want to process the\n",
      " |      individual arguments of the tail of self as an Add.\n",
      " |      \n",
      " |      - if you know self is an Add and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail.\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_add()\n",
      " |      (3, ())\n",
      " |      >>> (3 + x).as_coeff_add()\n",
      " |      (3, (x,))\n",
      " |      >>> (3 + x + y).as_coeff_add(x)\n",
      " |      (y + 3, (x,))\n",
      " |      >>> (3 + y).as_coeff_add(x)\n",
      " |      (y + 3, ())\n",
      " |  \n",
      " |  as_coeff_exponent(self, x) -> 'tuple[Expr, Expr]'\n",
      " |      ``c*x**e -> c,e`` where x can be any symbolic expression.\n",
      " |  \n",
      " |  as_coeff_mul(self, *deps, **kwargs) -> 'tuple[Expr, tuple[Expr, ...]]'\n",
      " |      Return the tuple (c, args) where self is written as a Mul, ``m``.\n",
      " |      \n",
      " |      c should be a Rational multiplied by any factors of the Mul that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other factors of m; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is a Mul or not but\n",
      " |      you want to treat self as a Mul or if you want to process the\n",
      " |      individual arguments of the tail of self as a Mul.\n",
      " |      \n",
      " |      - if you know self is a Mul and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail;\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_mul()\n",
      " |      (3, ())\n",
      " |      >>> (3*x*y).as_coeff_mul()\n",
      " |      (3, (x, y))\n",
      " |      >>> (3*x*y).as_coeff_mul(x)\n",
      " |      (3*y, (x,))\n",
      " |      >>> (3*y).as_coeff_mul(x)\n",
      " |      (3*y, ())\n",
      " |  \n",
      " |  as_coefficient(self, expr)\n",
      " |      Extracts symbolic coefficient at the given expression. In\n",
      " |      other words, this functions separates 'self' into the product\n",
      " |      of 'expr' and 'expr'-free coefficient. If such separation\n",
      " |      is not possible it will return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import E, pi, sin, I, Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> E.as_coefficient(E)\n",
      " |      1\n",
      " |      >>> (2*E).as_coefficient(E)\n",
      " |      2\n",
      " |      >>> (2*sin(E)*E).as_coefficient(E)\n",
      " |      \n",
      " |      Two terms have E in them so a sum is returned. (If one were\n",
      " |      desiring the coefficient of the term exactly matching E then\n",
      " |      the constant from the returned expression could be selected.\n",
      " |      Or, for greater precision, a method of Poly can be used to\n",
      " |      indicate the desired term from which the coefficient is\n",
      " |      desired.)\n",
      " |      \n",
      " |      >>> (2*E + x*E).as_coefficient(E)\n",
      " |      x + 2\n",
      " |      >>> _.args[0]  # just want the exact match\n",
      " |      2\n",
      " |      >>> p = Poly(2*E + x*E); p\n",
      " |      Poly(x*E + 2*E, x, E, domain='ZZ')\n",
      " |      >>> p.coeff_monomial(E)\n",
      " |      2\n",
      " |      >>> p.nth(0, 1)\n",
      " |      2\n",
      " |      \n",
      " |      Since the following cannot be written as a product containing\n",
      " |      E as a factor, None is returned. (If the coefficient ``2*x`` is\n",
      " |      desired then the ``coeff`` method should be used.)\n",
      " |      \n",
      " |      >>> (2*E*x + x).as_coefficient(E)\n",
      " |      >>> (2*E*x + x).coeff(E)\n",
      " |      2*x\n",
      " |      \n",
      " |      >>> (E*(x + 1) + x).as_coefficient(E)\n",
      " |      \n",
      " |      >>> (2*pi*I).as_coefficient(pi*I)\n",
      " |      2\n",
      " |      >>> (2*I).as_coefficient(pi*I)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      coeff: return sum of terms have a given factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  as_coefficients_dict(self, *syms)\n",
      " |      Return a dictionary mapping terms to their Rational coefficient.\n",
      " |      Since the dictionary is a defaultdict, inquiries about terms which\n",
      " |      were not present will return a coefficient of 0.\n",
      " |      \n",
      " |      If symbols ``syms`` are provided, any multiplicative terms\n",
      " |      independent of them will be considered a coefficient and a\n",
      " |      regular dictionary of syms-dependent generators as keys and\n",
      " |      their corresponding coefficients as values will be returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import a, x, y\n",
      " |      >>> (3*x + a*x + 4).as_coefficients_dict()\n",
      " |      {1: 4, x: 3, a*x: 1}\n",
      " |      >>> _[a]\n",
      " |      0\n",
      " |      >>> (3*a*x).as_coefficients_dict()\n",
      " |      {a*x: 3}\n",
      " |      >>> (3*a*x).as_coefficients_dict(x)\n",
      " |      {x: 3*a}\n",
      " |      >>> (3*a*x).as_coefficients_dict(y)\n",
      " |      {1: 3*a*x}\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      This method should recursively remove a Rational from all arguments\n",
      " |      and return that (content) and the new self (primitive). The content\n",
      " |      should always be positive and ``Mul(*foo.as_content_primitive()) == foo``.\n",
      " |      The primitive need not be in canonical form and should try to preserve\n",
      " |      the underlying structure if possible (i.e. expand_mul should not be\n",
      " |      applied to self).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> eq = 2 + 2*x + 2*y*(3 + 3*y)\n",
      " |      \n",
      " |      The as_content_primitive function is recursive and retains structure:\n",
      " |      \n",
      " |      >>> eq.as_content_primitive()\n",
      " |      (2, x + 3*y*(y + 1) + 1)\n",
      " |      \n",
      " |      Integer powers will have Rationals extracted from the base:\n",
      " |      \n",
      " |      >>> ((2 + 6*x)**2).as_content_primitive()\n",
      " |      (4, (3*x + 1)**2)\n",
      " |      >>> ((2 + 6*x)**(2*y)).as_content_primitive()\n",
      " |      (1, (2*(3*x + 1))**(2*y))\n",
      " |      \n",
      " |      Terms may end up joining once their as_content_primitives are added:\n",
      " |      \n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (11, x*(y + 1))\n",
      " |      >>> ((3*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (9, x*(y + 1))\n",
      " |      >>> ((3*(z*(1 + y)) + 2.0*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (1, 6.0*x*(y + 1) + 3*z*(y + 1))\n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (121, x**2*(y + 1)**2)\n",
      " |      >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (1, 4.84*x**2*(y + 1)**2)\n",
      " |      \n",
      " |      Radical content can also be factored out of the primitive:\n",
      " |      \n",
      " |      >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)\n",
      " |      (2, sqrt(2)*(1 + 2*sqrt(5)))\n",
      " |      \n",
      " |      If clear=False (default is True) then content will not be removed\n",
      " |      from an Add if it can be distributed to leave one or more\n",
      " |      terms with integer coefficients.\n",
      " |      \n",
      " |      >>> (x/2 + y).as_content_primitive()\n",
      " |      (1/2, x + 2*y)\n",
      " |      >>> (x/2 + y).as_content_primitive(clear=False)\n",
      " |      (1, x/2 + y)\n",
      " |  \n",
      " |  as_expr(self, *gens)\n",
      " |      Convert a polynomial to a SymPy expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = (x**2 + x*y).as_poly(x, y)\n",
      " |      >>> f.as_expr()\n",
      " |      x**2 + x*y\n",
      " |      \n",
      " |      >>> sin(x).as_expr()\n",
      " |      sin(x)\n",
      " |  \n",
      " |  as_independent(self, *deps, **hint) -> 'tuple[Expr, Expr]'\n",
      " |      A mostly naive separation of a Mul or Add into arguments that are not\n",
      " |      are dependent on deps. To obtain as complete a separation of variables\n",
      " |      as possible, use a separation method first, e.g.:\n",
      " |      \n",
      " |      * separatevars() to change Mul, Add and Pow (including exp) into Mul\n",
      " |      * .expand(mul=True) to change Add or Mul into Add\n",
      " |      * .expand(log=True) to change log expr into an Add\n",
      " |      \n",
      " |      The only non-naive thing that is done here is to respect noncommutative\n",
      " |      ordering of variables and to always return (0, 0) for `self` of zero\n",
      " |      regardless of hints.\n",
      " |      \n",
      " |      For nonzero `self`, the returned tuple (i, d) has the\n",
      " |      following interpretation:\n",
      " |      \n",
      " |      * i will has no variable that appears in deps\n",
      " |      * d will either have terms that contain variables that are in deps, or\n",
      " |        be equal to 0 (when self is an Add) or 1 (when self is a Mul)\n",
      " |      * if self is an Add then self = i + d\n",
      " |      * if self is a Mul then self = i*d\n",
      " |      * otherwise (self, S.One) or (S.One, self) is returned.\n",
      " |      \n",
      " |      To force the expression to be treated as an Add, use the hint as_Add=True\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      -- self is an Add\n",
      " |      \n",
      " |      >>> from sympy import sin, cos, exp\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> (x + x*y).as_independent(x)\n",
      " |      (0, x*y + x)\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x)\n",
      " |      (y + z, 2*x*sin(x) + x)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x, y)\n",
      " |      (z, 2*x*sin(x) + x + y)\n",
      " |      \n",
      " |      -- self is a Mul\n",
      " |      \n",
      " |      >>> (x*sin(x)*cos(y)).as_independent(x)\n",
      " |      (cos(y), x*sin(x))\n",
      " |      \n",
      " |      non-commutative terms cannot always be separated out when self is a Mul\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False)\n",
      " |      >>> (n1 + n1*n2).as_independent(n2)\n",
      " |      (n1, n1*n2)\n",
      " |      >>> (n2*n1 + n1*n2).as_independent(n2)\n",
      " |      (0, n1*n2 + n2*n1)\n",
      " |      >>> (n1*n2*n3).as_independent(n1)\n",
      " |      (1, n1*n2*n3)\n",
      " |      >>> (n1*n2*n3).as_independent(n2)\n",
      " |      (n1, n2*n3)\n",
      " |      >>> ((x-n1)*(x-y)).as_independent(x)\n",
      " |      (1, (x - y)*(x - n1))\n",
      " |      \n",
      " |      -- self is anything else:\n",
      " |      \n",
      " |      >>> (sin(x)).as_independent(x)\n",
      " |      (1, sin(x))\n",
      " |      >>> (sin(x)).as_independent(y)\n",
      " |      (sin(x), 1)\n",
      " |      >>> exp(x+y).as_independent(x)\n",
      " |      (1, exp(x + y))\n",
      " |      \n",
      " |      -- force self to be treated as an Add:\n",
      " |      \n",
      " |      >>> (3*x).as_independent(x, as_Add=True)\n",
      " |      (0, 3*x)\n",
      " |      \n",
      " |      -- force self to be treated as a Mul:\n",
      " |      \n",
      " |      >>> (3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x + 3)\n",
      " |      >>> (-3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x - 3)\n",
      " |      \n",
      " |      Note how the below differs from the above in making the\n",
      " |      constant on the dep term positive.\n",
      " |      \n",
      " |      >>> (y*(-3+x)).as_independent(x)\n",
      " |      (y, x - 3)\n",
      " |      \n",
      " |      -- use .as_independent() for true independence testing instead\n",
      " |         of .has(). The former considers only symbols in the free\n",
      " |         symbols while the latter considers all symbols\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> I = Integral(x, (x, 1, 2))\n",
      " |      >>> I.has(x)\n",
      " |      True\n",
      " |      >>> x in I.free_symbols\n",
      " |      False\n",
      " |      >>> I.as_independent(x) == (I, 1)\n",
      " |      True\n",
      " |      >>> (I + x).as_independent(x) == (I, x)\n",
      " |      True\n",
      " |      \n",
      " |      Note: when trying to get independent terms, a separation method\n",
      " |      might need to be used first. In this case, it is important to keep\n",
      " |      track of what you send to this routine so you know how to interpret\n",
      " |      the returned values\n",
      " |      \n",
      " |      >>> from sympy import separatevars, log\n",
      " |      >>> separatevars(exp(x+y)).as_independent(x)\n",
      " |      (exp(y), exp(x))\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> separatevars(x + x*y).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).expand(mul=True).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> a, b=symbols('a b', positive=True)\n",
      " |      >>> (log(a*b).expand(log=True)).as_independent(b)\n",
      " |      (log(a), log(b))\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      separatevars\n",
      " |      expand_log\n",
      " |      sympy.core.add.Add.as_two_terms\n",
      " |      sympy.core.mul.Mul.as_two_terms\n",
      " |      as_coeff_mul\n",
      " |  \n",
      " |  as_leading_term(self, *symbols, logx=None, cdir=0)\n",
      " |      Returns the leading (nonzero) term of the series expansion of self.\n",
      " |      \n",
      " |      The _eval_as_leading_term routines are used to do this, and they must\n",
      " |      always return a non-zero value.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + x**2).as_leading_term(x)\n",
      " |      1\n",
      " |      >>> (1/x**2 + x + x**2).as_leading_term(x)\n",
      " |      x**(-2)\n",
      " |  \n",
      " |  as_numer_denom(self)\n",
      " |      Return the numerator and the denominator of an expression.\n",
      " |      \n",
      " |      expression -> a/b -> a, b\n",
      " |      \n",
      " |      This is just a stub that should be defined by\n",
      " |      an object's class methods to get anything else.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      normal: return ``a/b`` instead of ``(a, b)``\n",
      " |  \n",
      " |  as_ordered_factors(self, order=None)\n",
      " |      Return list of ordered factors (if Mul) else [self].\n",
      " |  \n",
      " |  as_ordered_terms(self, order=None, data=False)\n",
      " |      Transform an expression to an ordered list of terms.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, cos\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()\n",
      " |      [sin(x)**2*cos(x), sin(x)**2, 1]\n",
      " |  \n",
      " |  as_poly(self, *gens, **args)\n",
      " |      Converts ``self`` to a polynomial or returns ``None``.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly())\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly(x, y))\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + sin(y)).as_poly(x, y))\n",
      " |      None\n",
      " |  \n",
      " |  as_powers_dict(self)\n",
      " |      Return self as a dictionary of factors with each factor being\n",
      " |      treated as a power. The keys are the bases of the factors and the\n",
      " |      values, the corresponding exponents. The resulting dictionary should\n",
      " |      be used with caution if the expression is a Mul and contains non-\n",
      " |      commutative factors since the order that they appeared will be lost in\n",
      " |      the dictionary.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      as_ordered_factors: An alternative for noncommutative applications,\n",
      " |                          returning an ordered list of factors.\n",
      " |      args_cnc: Similar to as_ordered_factors, but guarantees separation\n",
      " |                of commutative and noncommutative factors.\n",
      " |  \n",
      " |  as_real_imag(self, deep=True, **hints)\n",
      " |      Performs complex expansion on 'self' and returns a tuple\n",
      " |      containing collected both real and imaginary parts. This\n",
      " |      method cannot be confused with re() and im() functions,\n",
      " |      which does not perform complex expansion at evaluation.\n",
      " |      \n",
      " |      However it is possible to expand both re() and im()\n",
      " |      functions and get exactly the same results as with\n",
      " |      a single call to this function.\n",
      " |      \n",
      " |      >>> from sympy import symbols, I\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> (x + y*I).as_real_imag()\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> from sympy.abc import z, w\n",
      " |      \n",
      " |      >>> (z + w*I).as_real_imag()\n",
      " |      (re(z) - im(w), re(w) + im(z))\n",
      " |  \n",
      " |  as_terms(self)\n",
      " |      Transform an expression to a list of terms.\n",
      " |  \n",
      " |  aseries(self, x=None, n=6, bound=0, hir=False)\n",
      " |      Asymptotic Series expansion of self.\n",
      " |      This is equivalent to ``self.series(x, oo, n)``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      self : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |      \n",
      " |      hir : Boolean\n",
      " |            Set this parameter to be True to produce hierarchical series.\n",
      " |            It stops the recursion at an early level and may provide nicer\n",
      " |            and more useful results.\n",
      " |      \n",
      " |      bound : Value, Integer\n",
      " |              Use the ``bound`` parameter to give limit on rewriting\n",
      " |              coefficients in its normalised form.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, exp\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> e = sin(1/x + exp(-x)) - sin(1/x)\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)\n",
      " |      \n",
      " |      >>> e.aseries(x, n=3, hir=True)\n",
      " |      -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))\n",
      " |      \n",
      " |      >>> e = exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x, bound=3) # doctest: +SKIP\n",
      " |      exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))\n",
      " |      \n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).aseries(x, n=8)\n",
      " |      1/x\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr\n",
      " |          Asymptotic series expansion of the expression.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      This algorithm is directly induced from the limit computational algorithm provided by Gruntz.\n",
      " |      It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first\n",
      " |      to look for the most rapidly varying subexpression w of a given expression f and then expands f\n",
      " |      in a series in w. Then same thing is recursively done on the leading coefficient\n",
      " |      till we get constant coefficients.\n",
      " |      \n",
      " |      If the most rapidly varying subexpression of a given expression f is f itself,\n",
      " |      the algorithm tries to find a normalised representation of the mrv set and rewrites f\n",
      " |      using this normalised representation.\n",
      " |      \n",
      " |      If the expansion contains an order term, it will be either ``O(x ** (-n))`` or ``O(w ** (-n))``\n",
      " |      where ``w`` belongs to the most rapidly varying expression of ``self``.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] Gruntz, Dominik. A new algorithm for computing asymptotic series.\n",
      " |             In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993.\n",
      " |             pp. 239-244.\n",
      " |      .. [2] Gruntz thesis - p90\n",
      " |      .. [3] https://en.wikipedia.org/wiki/Asymptotic_expansion\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      Expr.aseries: See the docstring of this function for complete details of this wrapper.\n",
      " |  \n",
      " |  cancel(self, *gens, **args)\n",
      " |      See the cancel function in sympy.polys\n",
      " |  \n",
      " |  coeff(self, x, n=1, right=False, _first=True)\n",
      " |      Returns the coefficient from the term(s) containing ``x**n``. If ``n``\n",
      " |      is zero then all terms independent of ``x`` will be returned.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      When ``x`` is noncommutative, the coefficient to the left (default) or\n",
      " |      right of ``x`` can be returned. The keyword 'right' is ignored when\n",
      " |      ``x`` is commutative.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      You can select terms that have an explicit negative in front of them:\n",
      " |      \n",
      " |      >>> (-x + 2*y).coeff(-1)\n",
      " |      x\n",
      " |      >>> (x - 2*y).coeff(-1)\n",
      " |      2*y\n",
      " |      \n",
      " |      You can select terms with no Rational coefficient:\n",
      " |      \n",
      " |      >>> (x + 2*y).coeff(1)\n",
      " |      x\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(1)\n",
      " |      0\n",
      " |      \n",
      " |      You can select terms independent of x by making n=0; in this case\n",
      " |      expr.as_independent(x)[0] is returned (and 0 will be returned instead\n",
      " |      of None):\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x, 0)\n",
      " |      3\n",
      " |      >>> eq = ((x + 1)**3).expand() + 1\n",
      " |      >>> eq\n",
      " |      x**3 + 3*x**2 + 3*x + 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 2]\n",
      " |      >>> eq -= 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 0]\n",
      " |      \n",
      " |      You can select terms that have a numerical term in front of them:\n",
      " |      \n",
      " |      >>> (-x - 2*y).coeff(2)\n",
      " |      -y\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> (x + sqrt(2)*x).coeff(sqrt(2))\n",
      " |      x\n",
      " |      \n",
      " |      The matching is exact:\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x)\n",
      " |      2\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**2)\n",
      " |      4\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**3)\n",
      " |      0\n",
      " |      >>> (z*(x + y)**2).coeff((x + y)**2)\n",
      " |      z\n",
      " |      >>> (z*(x + y)**2).coeff(x + y)\n",
      " |      0\n",
      " |      \n",
      " |      In addition, no factoring is done, so 1 + z*(1 + y) is not obtained\n",
      " |      from the following:\n",
      " |      \n",
      " |      >>> (x + z*(x + x*y)).coeff(x)\n",
      " |      1\n",
      " |      \n",
      " |      If such factoring is desired, factor_terms can be used first:\n",
      " |      \n",
      " |      >>> from sympy import factor_terms\n",
      " |      >>> factor_terms(x + z*(x + x*y)).coeff(x)\n",
      " |      z*(y + 1) + 1\n",
      " |      \n",
      " |      >>> n, m, o = symbols('n m o', commutative=False)\n",
      " |      >>> n.coeff(n)\n",
      " |      1\n",
      " |      >>> (3*n).coeff(n)\n",
      " |      3\n",
      " |      >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m\n",
      " |      1 + m\n",
      " |      >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m\n",
      " |      m\n",
      " |      \n",
      " |      If there is more than one possible coefficient 0 is returned:\n",
      " |      \n",
      " |      >>> (n*m + m*n).coeff(n)\n",
      " |      0\n",
      " |      \n",
      " |      If there is only one possible coefficient, it is returned:\n",
      " |      \n",
      " |      >>> (n*m + x*m*n).coeff(m*n)\n",
      " |      x\n",
      " |      >>> (n*m + x*m*n).coeff(m*n, right=1)\n",
      " |      1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_coefficient: separate the expression into a coefficient and factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  collect(self, syms, func=None, evaluate=True, exact=False, distribute_order_term=True)\n",
      " |      See the collect function in sympy.simplify\n",
      " |  \n",
      " |  combsimp(self)\n",
      " |      See the combsimp function in sympy.simplify\n",
      " |  \n",
      " |  compute_leading_term(self, x, logx=None)\n",
      " |      Deprecated function to compute the leading term of a series.\n",
      " |      \n",
      " |      as_leading_term is only allowed for results of .series()\n",
      " |      This is a wrapper to compute a series first.\n",
      " |  \n",
      " |  conjugate(self)\n",
      " |      Returns the complex conjugate of 'self'.\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |      Return True if self has -1 as a leading factor or has\n",
      " |      more literal negative signs than positive signs in a sum,\n",
      " |      otherwise False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = x - y\n",
      " |      >>> {i.could_extract_minus_sign() for i in (e, -e)}\n",
      " |      {False, True}\n",
      " |      \n",
      " |      Though the ``y - x`` is considered like ``-(x - y)``, since it\n",
      " |      is in a product without a leading factor of -1, the result is\n",
      " |      false below:\n",
      " |      \n",
      " |      >>> (x*(y - x)).could_extract_minus_sign()\n",
      " |      False\n",
      " |      \n",
      " |      To put something in canonical form wrt to sign, use `signsimp`:\n",
      " |      \n",
      " |      >>> from sympy import signsimp\n",
      " |      >>> signsimp(x*(y - x))\n",
      " |      -x*(x - y)\n",
      " |      >>> _.could_extract_minus_sign()\n",
      " |      True\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      Wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  diff(self, *symbols, **assumptions)\n",
      " |  \n",
      " |  dir(self, x, cdir)\n",
      " |  \n",
      " |  equals(self, other, failing_expression=False)\n",
      " |      Return True if self == other, False if it does not, or None. If\n",
      " |      failing_expression is True then the expression which did not simplify\n",
      " |      to a 0 will be returned instead of None.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If ``self`` is a Number (or complex number) that is not zero, then\n",
      " |      the result is False.\n",
      " |      \n",
      " |      If ``self`` is a number and has not evaluated to zero, evalf will be\n",
      " |      used to test whether the expression evaluates to zero. If it does so\n",
      " |      and the result has significance (i.e. the precision is either -1, for\n",
      " |      a Rational result, or is greater than 1) then the evalf value will be\n",
      " |      used to return True or False.\n",
      " |  \n",
      " |  expand(self, deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)\n",
      " |      Expand an expression using hints.\n",
      " |      \n",
      " |      See the docstring of the expand() function in sympy.core.function for\n",
      " |      more information.\n",
      " |  \n",
      " |  extract_additively(self, c)\n",
      " |      Return self - c if it's possible to subtract c from self and\n",
      " |      make all matching coefficients move towards zero, else return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = 2*x + 3\n",
      " |      >>> e.extract_additively(x + 1)\n",
      " |      x + 2\n",
      " |      >>> e.extract_additively(3*x)\n",
      " |      >>> e.extract_additively(4)\n",
      " |      >>> (y*(x + 1)).extract_additively(x + 1)\n",
      " |      >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)\n",
      " |      (x + 1)*(x + 2*y) + 3\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      extract_multiplicatively\n",
      " |      coeff\n",
      " |      as_coefficient\n",
      " |  \n",
      " |  extract_branch_factor(self, allow_half=False)\n",
      " |      Try to write self as ``exp_polar(2*pi*I*n)*z`` in a nice way.\n",
      " |      Return (z, n).\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, I, pi\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> exp_polar(I*pi).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), 0)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor()\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(-pi*I).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), -1)\n",
      " |      >>> exp_polar(3*pi*I + x).extract_branch_factor()\n",
      " |      (exp_polar(x + I*pi), 1)\n",
      " |      >>> (y*exp_polar(-5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor()\n",
      " |      (y*exp_polar(2*pi*x), -1)\n",
      " |      >>> exp_polar(-I*pi/2).extract_branch_factor()\n",
      " |      (exp_polar(-I*pi/2), 0)\n",
      " |      \n",
      " |      If allow_half is True, also extract exp_polar(I*pi):\n",
      " |      \n",
      " |      >>> exp_polar(I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1/2)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 3/2)\n",
      " |      >>> exp_polar(-I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, -1/2)\n",
      " |  \n",
      " |  extract_multiplicatively(self, c)\n",
      " |      Return None if it's not possible to make self in the form\n",
      " |      c * something in a nice way, i.e. preserving the properties\n",
      " |      of arguments of self.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Rational\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**2 * y)\n",
      " |      x*y**2\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**4 * y)\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(2)\n",
      " |      x\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(3)\n",
      " |      \n",
      " |      >>> (Rational(1, 2)*x).extract_multiplicatively(3)\n",
      " |      x/6\n",
      " |  \n",
      " |  factor(self, *gens, **args)\n",
      " |      See the factor() function in sympy.polys.polytools\n",
      " |  \n",
      " |  fourier_series(self, limits=None)\n",
      " |      Compute fourier sine/cosine series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fourier_series` in sympy.series.fourier\n",
      " |      for more information.\n",
      " |  \n",
      " |  fps(self, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)\n",
      " |      Compute formal power power series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fps` function in sympy.series.formal for\n",
      " |      more information.\n",
      " |  \n",
      " |  gammasimp(self)\n",
      " |      See the gammasimp function in sympy.simplify\n",
      " |  \n",
      " |  getO(self)\n",
      " |      Returns the additive O(..) symbol if there is one, else None.\n",
      " |  \n",
      " |  getn(self)\n",
      " |      Returns the order of the expression.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The order is determined either from the O(...) term. If there\n",
      " |      is no O(...) term, it returns None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import O\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + O(x**2)).getn()\n",
      " |      2\n",
      " |      >>> (1 + x).getn()\n",
      " |  \n",
      " |  integrate(self, *args, **kwargs)\n",
      " |      See the integrate function in sympy.integrals\n",
      " |  \n",
      " |  invert(self, g, *gens, **args)\n",
      " |      Return the multiplicative inverse of ``self`` mod ``g``\n",
      " |      where ``self`` (and ``g``) may be symbolic expressions).\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      sympy.core.numbers.mod_inverse, sympy.polys.polytools.invert\n",
      " |  \n",
      " |  is_algebraic_expr(self, *syms)\n",
      " |      This tests whether a given expression is algebraic or not, in the\n",
      " |      given symbols, syms. When syms is not given, all free symbols\n",
      " |      will be used. The rational function does not have to be in expanded\n",
      " |      or in any kind of canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"algebraic\n",
      " |      expressions\" with symbolic exponents. This is a simple extension to the\n",
      " |      is_rational_function, including rational exponentiation.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sqrt\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> sqrt(1 + x).is_rational_function()\n",
      " |      False\n",
      " |      >>> sqrt(1 + x).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be an algebraic\n",
      " |      expression to become one.\n",
      " |      \n",
      " |      >>> from sympy import exp, factor\n",
      " |      >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)\n",
      " |      >>> a.is_algebraic_expr(x)\n",
      " |      False\n",
      " |      >>> factor(a).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      is_rational_function\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Algebraic_expression\n",
      " |  \n",
      " |  is_constant(self, *wrt, **flags)\n",
      " |      Return True if self is constant, False if not, or None if\n",
      " |      the constancy could not be determined conclusively.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If an expression has no free symbols then it is a constant. If\n",
      " |      there are free symbols it is possible that the expression is a\n",
      " |      constant, perhaps (but not necessarily) zero. To test such\n",
      " |      expressions, a few strategies are tried:\n",
      " |      \n",
      " |      1) numerical evaluation at two random points. If two such evaluations\n",
      " |      give two different values and the values have a precision greater than\n",
      " |      1 then self is not constant. If the evaluations agree or could not be\n",
      " |      obtained with any precision, no decision is made. The numerical testing\n",
      " |      is done only if ``wrt`` is different than the free symbols.\n",
      " |      \n",
      " |      2) differentiation with respect to variables in 'wrt' (or all free\n",
      " |      symbols if omitted) to see if the expression is constant or not. This\n",
      " |      will not always lead to an expression that is zero even though an\n",
      " |      expression is constant (see added test in test_expr.py). If\n",
      " |      all derivatives are zero then self is constant with respect to the\n",
      " |      given symbols.\n",
      " |      \n",
      " |      3) finding out zeros of denominator expression with free_symbols.\n",
      " |      It will not be constant if there are zeros. It gives more negative\n",
      " |      answers for expression that are not constant.\n",
      " |      \n",
      " |      If neither evaluation nor differentiation can prove the expression is\n",
      " |      constant, None is returned unless two numerical values happened to be\n",
      " |      the same and the flag ``failing_number`` is True -- in that case the\n",
      " |      numerical value will be returned.\n",
      " |      \n",
      " |      If flag simplify=False is passed, self will not be simplified;\n",
      " |      the default is True since self should be simplified before testing.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, Sum, S, pi\n",
      " |      >>> from sympy.abc import a, n, x, y\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> S(2).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, 10)).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant()\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(y)\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(n)\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(x)\n",
      " |      True\n",
      " |      >>> eq = a*cos(x)**2 + a*sin(x)**2 - a\n",
      " |      >>> eq.is_constant()\n",
      " |      True\n",
      " |      >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0\n",
      " |      True\n",
      " |      \n",
      " |      >>> (0**x).is_constant()\n",
      " |      False\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> (x**x).is_constant()\n",
      " |      False\n",
      " |      >>> one = cos(x)**2 + sin(x)**2\n",
      " |      >>> one.is_constant()\n",
      " |      True\n",
      " |      >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1\n",
      " |      True\n",
      " |  \n",
      " |  is_meromorphic(self, x, a)\n",
      " |      This tests whether an expression is meromorphic as\n",
      " |      a function of the given symbol ``x`` at the point ``a``.\n",
      " |      \n",
      " |      This method is intended as a quick test that will return\n",
      " |      None if no decision can be made without simplification or\n",
      " |      more detailed analysis.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import zoo, log, sin, sqrt\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = 1/x**2 + 1 - 2*x**3\n",
      " |      >>> f.is_meromorphic(x, 0)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      >>> g = x**log(3)\n",
      " |      >>> g.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> g.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> g.is_meromorphic(x, zoo)\n",
      " |      False\n",
      " |      \n",
      " |      >>> h = sin(1/x)*x**2\n",
      " |      >>> h.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> h.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> h.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      Multivalued functions are considered meromorphic when their\n",
      " |      branches are meromorphic. Thus most functions are meromorphic\n",
      " |      everywhere except at essential singularities and branch points.\n",
      " |      In particular, they will be meromorphic also on branch cuts\n",
      " |      except at their endpoints.\n",
      " |      \n",
      " |      >>> log(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> log(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> sqrt(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> sqrt(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |  \n",
      " |  is_polynomial(self, *syms)\n",
      " |      Return True if self is a polynomial in syms and False otherwise.\n",
      " |      \n",
      " |      This checks if self is an exact polynomial in syms.  This function\n",
      " |      returns False for expressions that are \"polynomials\" with symbolic\n",
      " |      exponents.  Thus, you should be able to apply polynomial algorithms to\n",
      " |      expressions for which this returns True, and Poly(expr, \\*syms) should\n",
      " |      work if and only if expr.is_polynomial(\\*syms) returns True. The\n",
      " |      polynomial does not have to be in expanded form.  If no symbols are\n",
      " |      given, all free symbols in the expression will be used.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', polynomial=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, Function\n",
      " |      >>> x = Symbol('x')\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial(x)\n",
      " |      True\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial()\n",
      " |      True\n",
      " |      >>> (2**x + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (2**x + 1).is_polynomial(2**x)\n",
      " |      True\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (f(x) + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (f(x) + 1).is_polynomial(f(x))\n",
      " |      True\n",
      " |      >>> (1/f(x) + 1).is_polynomial(f(x))\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', nonnegative=True, integer=True)\n",
      " |      >>> (x**n + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a polynomial to\n",
      " |      become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor, cancel\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)\n",
      " |      >>> a.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      y + 1\n",
      " |      >>> factor(a).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      >>> b = (y**2 + 2*y + 1)/(y + 1)\n",
      " |      >>> b.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> cancel(b)\n",
      " |      y + 1\n",
      " |      >>> cancel(b).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also .is_rational_function()\n",
      " |  \n",
      " |  is_rational_function(self, *syms)\n",
      " |      Test whether function is a ratio of two polynomials in the given\n",
      " |      symbols, syms. When syms is not given, all free symbols will be used.\n",
      " |      The rational function does not have to be in expanded or in any kind of\n",
      " |      canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"rational\n",
      " |      functions\" with symbolic exponents.  Thus, you should be able to call\n",
      " |      .as_numer_denom() and apply polynomial algorithms to the result for\n",
      " |      expressions for which this returns True.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', rational_function=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> (x/y).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x**2).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x/sin(y)).is_rational_function(y)\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', integer=True)\n",
      " |      >>> (x**n + 1).is_rational_function(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a rational function\n",
      " |      to become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)/y\n",
      " |      >>> a.is_rational_function(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      (y + 1)/y\n",
      " |      >>> factor(a).is_rational_function(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also is_algebraic_expr().\n",
      " |  \n",
      " |  leadterm(self, x, logx=None, cdir=0)\n",
      " |      Returns the leading term a*x**b as a tuple (a, b).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1+x+x**2).leadterm(x)\n",
      " |      (1, 0)\n",
      " |      >>> (1/x**2+x+x**2).leadterm(x)\n",
      " |      (1, -2)\n",
      " |  \n",
      " |  limit(self, x, xlim, dir='+')\n",
      " |      Compute limit x->xlim.\n",
      " |  \n",
      " |  lseries(self, x=None, x0=0, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper for series yielding an iterator of the terms of the series.\n",
      " |      \n",
      " |      Note: an infinite series will yield an infinite iterator. The following,\n",
      " |      for exaxmple, will never terminate. It will just keep printing terms\n",
      " |      of the sin(x) series::\n",
      " |      \n",
      " |        for term in sin(x).lseries(x):\n",
      " |            print term\n",
      " |      \n",
      " |      The advantage of lseries() over nseries() is that many times you are\n",
      " |      just interested in the next term in the series (i.e. the first term for\n",
      " |      example), but you do not know how many you should ask for in nseries()\n",
      " |      using the \"n\" parameter.\n",
      " |      \n",
      " |      See also nseries().\n",
      " |  \n",
      " |  normal(self)\n",
      " |      Return the expression as a fraction.\n",
      " |      \n",
      " |      expression -> a/b\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_numer_denom: return ``(a, b)`` instead of ``a/b``\n",
      " |  \n",
      " |  nseries(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper to _eval_nseries if assumptions allow, else to series.\n",
      " |      \n",
      " |      If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is\n",
      " |      called. This calculates \"n\" terms in the innermost expressions and\n",
      " |      then builds up the final series just by \"cross-multiplying\" everything\n",
      " |      out.\n",
      " |      \n",
      " |      The optional ``logx`` parameter can be used to replace any log(x) in the\n",
      " |      returned series with a symbolic value to avoid evaluating log(x) at 0. A\n",
      " |      symbol to use in place of log(x) should be provided.\n",
      " |      \n",
      " |      Advantage -- it's fast, because we do not have to determine how many\n",
      " |      terms we need to calculate in advance.\n",
      " |      \n",
      " |      Disadvantage -- you may end up with less terms than you may have\n",
      " |      expected, but the O(x**n) term appended will always be correct and\n",
      " |      so the result, though perhaps shorter, will also be correct.\n",
      " |      \n",
      " |      If any of those assumptions is not met, this is treated like a\n",
      " |      wrapper to series which will try harder to return the correct\n",
      " |      number of terms.\n",
      " |      \n",
      " |      See also lseries().\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, log, Symbol\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> sin(x).nseries(x, 0, 6)\n",
      " |      x - x**3/6 + x**5/120 + O(x**6)\n",
      " |      >>> log(x+1).nseries(x, 0, 5)\n",
      " |      x - x**2/2 + x**3/3 - x**4/4 + O(x**5)\n",
      " |      \n",
      " |      Handling of the ``logx`` parameter --- in the following example the\n",
      " |      expansion fails since ``sin`` does not have an asymptotic expansion\n",
      " |      at -oo (the limit of log(x) as x approaches 0):\n",
      " |      \n",
      " |      >>> e = sin(log(x))\n",
      " |      >>> e.nseries(x, 0, 6)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      PoleError: ...\n",
      " |      ...\n",
      " |      >>> logx = Symbol('logx')\n",
      " |      >>> e.nseries(x, 0, 6, logx=logx)\n",
      " |      sin(logx)\n",
      " |      \n",
      " |      In the following example, the expansion works but only returns self\n",
      " |      unless the ``logx`` parameter is used:\n",
      " |      \n",
      " |      >>> e = x**y\n",
      " |      >>> e.nseries(x, 0, 2)\n",
      " |      x**y\n",
      " |      >>> e.nseries(x, 0, 2, logx=logx)\n",
      " |      exp(logx*y)\n",
      " |  \n",
      " |  nsimplify(self, constants=(), tolerance=None, full=False)\n",
      " |      See the nsimplify function in sympy.simplify\n",
      " |  \n",
      " |  powsimp(self, *args, **kwargs)\n",
      " |      See the powsimp function in sympy.simplify\n",
      " |  \n",
      " |  primitive(self)\n",
      " |      Return the positive Rational that can be extracted non-recursively\n",
      " |      from every term of self (i.e., self is treated like an Add). This is\n",
      " |      like the as_coeff_Mul() method but primitive always extracts a positive\n",
      " |      Rational (never a negative or a Float).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (3*(x + 1)**2).primitive()\n",
      " |      (3, (x + 1)**2)\n",
      " |      >>> a = (6*x + 2); a.primitive()\n",
      " |      (2, 3*x + 1)\n",
      " |      >>> b = (x/2 + 3); b.primitive()\n",
      " |      (1/2, x + 6)\n",
      " |      >>> (a*b).primitive() == (1, a*b)\n",
      " |      True\n",
      " |  \n",
      " |  radsimp(self, **kwargs)\n",
      " |      See the radsimp function in sympy.simplify\n",
      " |  \n",
      " |  ratsimp(self)\n",
      " |      See the ratsimp function in sympy.simplify\n",
      " |  \n",
      " |  removeO(self)\n",
      " |      Removes the additive O(..) symbol if there is one\n",
      " |  \n",
      " |  round(self, n=None)\n",
      " |      Return x rounded to the given decimal place.\n",
      " |      \n",
      " |      If a complex number would results, apply round to the real\n",
      " |      and imaginary components of the number.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, E, I, S, Number\n",
      " |      >>> pi.round()\n",
      " |      3\n",
      " |      >>> pi.round(2)\n",
      " |      3.14\n",
      " |      >>> (2*pi + E*I).round()\n",
      " |      6 + 3*I\n",
      " |      \n",
      " |      The round method has a chopping effect:\n",
      " |      \n",
      " |      >>> (2*pi + I/10).round()\n",
      " |      6\n",
      " |      >>> (pi/10 + 2*I).round()\n",
      " |      2*I\n",
      " |      >>> (pi/10 + E*I).round(2)\n",
      " |      0.31 + 2.72*I\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      The Python ``round`` function uses the SymPy ``round`` method so it\n",
      " |      will always return a SymPy number (not a Python float or int):\n",
      " |      \n",
      " |      >>> isinstance(round(S(123), -2), Number)\n",
      " |      True\n",
      " |  \n",
      " |  separate(self, deep=False, force=False)\n",
      " |      See the separate function in sympy.simplify\n",
      " |  \n",
      " |  series(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Series expansion of \"self\" around ``x = x0`` yielding either terms of\n",
      " |      the series one by one (the lazy series given when n=None), else\n",
      " |      all the terms at once when n != None.\n",
      " |      \n",
      " |      Returns the series expansion of \"self\" around the point ``x = x0``\n",
      " |      with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6).\n",
      " |      \n",
      " |      If ``x=None`` and ``self`` is univariate, the univariate symbol will\n",
      " |      be supplied, otherwise an error will be raised.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      expr : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      x0 : Value\n",
      " |           The value around which ``x`` is calculated. Can be any value\n",
      " |           from ``-oo`` to ``oo``.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |      \n",
      " |      dir : String, optional\n",
      " |            The series-expansion can be bi-directional. If ``dir=\"+\"``,\n",
      " |            then (x->x0+). If ``dir=\"-\", then (x->x0-). For infinite\n",
      " |            ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined\n",
      " |            from the direction of the infinity (i.e., ``dir=\"-\"`` for\n",
      " |            ``oo``).\n",
      " |      \n",
      " |      logx : optional\n",
      " |             It is used to replace any log(x) in the returned series with a\n",
      " |             symbolic value rather than evaluating the actual value.\n",
      " |      \n",
      " |      cdir : optional\n",
      " |             It stands for complex direction, and indicates the direction\n",
      " |             from which the expansion needs to be evaluated.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, exp, tan\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> cos(x).series()\n",
      " |      1 - x**2/2 + x**4/24 + O(x**6)\n",
      " |      >>> cos(x).series(n=4)\n",
      " |      1 - x**2/2 + O(x**4)\n",
      " |      >>> cos(x).series(x, x0=1, n=2)\n",
      " |      cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1))\n",
      " |      >>> e = cos(x + exp(y))\n",
      " |      >>> e.series(y, n=2)\n",
      " |      cos(x + 1) - y*sin(x + 1) + O(y**2)\n",
      " |      >>> e.series(x, n=2)\n",
      " |      cos(exp(y)) - x*sin(exp(y)) + O(x**2)\n",
      " |      \n",
      " |      If ``n=None`` then a generator of the series terms will be returned.\n",
      " |      \n",
      " |      >>> term=cos(x).series(n=None)\n",
      " |      >>> [next(term) for i in range(2)]\n",
      " |      [1, -x**2/2]\n",
      " |      \n",
      " |      For ``dir=+`` (default) the series is calculated from the right and\n",
      " |      for ``dir=-`` the series from the left. For smooth functions this\n",
      " |      flag will not alter the results.\n",
      " |      \n",
      " |      >>> abs(x).series(dir=\"+\")\n",
      " |      x\n",
      " |      >>> abs(x).series(dir=\"-\")\n",
      " |      -x\n",
      " |      >>> f = tan(x)\n",
      " |      >>> f.series(x, 2, 6, \"+\")\n",
      " |      tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +\n",
      " |      (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +\n",
      " |      5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +\n",
      " |      2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))\n",
      " |      \n",
      " |      >>> f.series(x, 2, 3, \"-\")\n",
      " |      tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))\n",
      " |      + O((x - 2)**3, (x, 2))\n",
      " |      \n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).series(x, n=8)\n",
      " |      1/x\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr : Expression\n",
      " |          Series expansion of the expression about x0\n",
      " |      \n",
      " |      Raises\n",
      " |      ======\n",
      " |      \n",
      " |      TypeError\n",
      " |          If \"n\" and \"x0\" are infinity objects\n",
      " |      \n",
      " |      PoleError\n",
      " |          If \"x0\" is an infinity object\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  taylor_term(self, n, x, *previous_terms)\n",
      " |      General method for the taylor term.\n",
      " |      \n",
      " |      This method is slow, because it differentiates n-times. Subclasses can\n",
      " |      redefine it to make it faster by using the \"previous_terms\".\n",
      " |  \n",
      " |  together(self, *args, **kwargs)\n",
      " |      See the together function in sympy.polys\n",
      " |  \n",
      " |  transpose(self)\n",
      " |  \n",
      " |  trigsimp(self, **args)\n",
      " |      See the trigsimp function in sympy.simplify\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |      Like ``free_symbols``, but returns the free symbols only if\n",
      " |      they are contained in an expression node.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (x + y).expr_free_symbols # doctest: +SKIP\n",
      " |      {x, y}\n",
      " |      \n",
      " |      If the expression is contained in a non-expression object, do not return\n",
      " |      the free symbols. Compare:\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> t = Tuple(x + y)\n",
      " |      >>> t.expr_free_symbols # doctest: +SKIP\n",
      " |      set()\n",
      " |      >>> t.free_symbols\n",
      " |      {x, y}\n",
      " |  \n",
      " |  is_number\n",
      " |      Returns True if ``self`` has no free symbols and no\n",
      " |      undefined functions (AppliedUndef, to be precise). It will be\n",
      " |      faster than ``if not self.free_symbols``, however, since\n",
      " |      ``is_number`` will fail as soon as it hits a free symbol\n",
      " |      or undefined function.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Function, Integral, cos, sin, pi\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> f = Function('f')\n",
      " |      \n",
      " |      >>> x.is_number\n",
      " |      False\n",
      " |      >>> f(1).is_number\n",
      " |      False\n",
      " |      >>> (2*x).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, x)).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, (x, 1, 2))).is_number\n",
      " |      True\n",
      " |      \n",
      " |      Not all numbers are Numbers in the SymPy sense:\n",
      " |      \n",
      " |      >>> pi.is_number, pi.is_Number\n",
      " |      (True, False)\n",
      " |      \n",
      " |      If something is a number it should evaluate to a number with\n",
      " |      real and imaginary parts that are Numbers; the result may not\n",
      " |      be comparable, however, since the real and/or imaginary part\n",
      " |      of the result may not have precision.\n",
      " |      \n",
      " |      >>> cos(1).is_number and cos(1).is_comparable\n",
      " |      True\n",
      " |      \n",
      " |      >>> z = cos(1)**2 + sin(1)**2 - 1\n",
      " |      >>> z.is_number\n",
      " |      True\n",
      " |      >>> z.is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.basic.Basic.is_comparable\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  is_scalar = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from https://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      Return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  has_xfree(self, s: 'set[Basic]')\n",
      " |      Return True if self has any of the patterns in s as a\n",
      " |      free argument, else False. This is like `Basic.has_free`\n",
      " |      but this will only report exact argument matches.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> f(x).has_xfree({f})\n",
      " |      False\n",
      " |      >>> f(x).has_xfree({f(x)})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x + 1})\n",
      " |      True\n",
      " |      >>> f(x + y + 1).has_xfree({x + 1})\n",
      " |      False\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : Expr\n",
      " |          A *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace lambda rule, **_\n",
      " |      # Function needs args so we define a property that returns\n",
      " |      # a function that takes args...and then use that function\n",
      " |      # to return the right value\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __init_subclass__() from sympy.core.function.FunctionClass\n",
      " |      This method is called when a class is subclassed.\n",
      " |      \n",
      " |      The default implementation does nothing. It may be\n",
      " |      overridden to extend subclasses.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.function.FunctionClass\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  kind = UndefinedKind\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(fibonacci)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n",
      "89\n",
      "144\n",
      "233\n",
      "377\n",
      "610\n",
      "987\n",
      "1597\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,18):\n",
    "    print(fibonacci(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr_f=a*(x+1)**2-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a \\left(x + 1\\right)^{2} - 1$"
      ],
      "text/plain": [
       "a*(x + 1)**2 - 1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr_g=cos(x)+2*a*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 a x + \\cos{\\left(x \\right)}$"
      ],
      "text/plain": [
       "2*a*x + cos(x)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=expand(expr_f-expr_g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a x^{2} + a - \\cos{\\left(x \\right)} - 1$"
      ],
      "text/plain": [
       "a*x**2 + a - cos(x) - 1"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{\\cos{\\left(x \\right)} + 1}{x^{2} + 1}\\right\\}$"
      ],
      "text/plain": [
       "{(cos(x) + 1)/(x**2 + 1)}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(check,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "check1=list(_)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\cos{\\left(x \\right)} + 1}{x^{2} + 1}$"
      ],
      "text/plain": [
       "(cos(x) + 1)/(x**2 + 1)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{x^{2} \\sin{\\left(x \\right)} + 2 x \\cos{\\left(x \\right)} + 2 x + \\sin{\\left(x \\right)}}{\\left(x^{2} + 1\\right)^{2}}$"
      ],
      "text/plain": [
       "-(x**2*sin(x) + 2*x*cos(x) + 2*x + sin(x))/(x**2 + 1)**2"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(check1,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "Unable to find critical points for (cos(x) + 1)/(x**2 + 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[15], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m function_range(check1,x,Interval\u001b[38;5;241m.\u001b[39mRopen(\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m1\u001b[39m))\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/calculus/util.py:200\u001b[0m, in \u001b[0;36mfunction_range\u001b[0;34m(f, symbol, domain)\u001b[0m\n\u001b[1;32m    197\u001b[0m solution \u001b[38;5;241m=\u001b[39m solveset(f\u001b[38;5;241m.\u001b[39mdiff(symbol), symbol, interval)\n\u001b[1;32m    199\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m iterable(solution):\n\u001b[0;32m--> 200\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m(\n\u001b[1;32m    201\u001b[0m             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mUnable to find critical points for \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mformat(f))\n\u001b[1;32m    202\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(solution, ImageSet):\n\u001b[1;32m    203\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m(\n\u001b[1;32m    204\u001b[0m             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mInfinite number of critical points for \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mformat(f))\n",
      "\u001b[0;31mNotImplementedError\u001b[0m: Unable to find critical points for (cos(x) + 1)/(x**2 + 1)"
     ]
    }
   ],
   "source": [
    "function_range(check1,x,Interval.Ropen(0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "quest=is_decreasing(check1,Interval.open(0,1),x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(quest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2$"
      ],
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check1.subs(x,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "q=QuadraticFunction(x**2+(x+1)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\left(x + \\frac{1}{2}\\right)^{2} + \\frac{1}{2}$"
      ],
      "text/plain": [
       "2*(x + 1/2)**2 + 1/2"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.symmetry_equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=2*x**3-3*a*x**2+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 3 a x^{2} + 2 x^{3} + 1$"
      ],
      "text/plain": [
       "-3*a*x**2 + 2*x**3 + 1"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 6 x \\left(- a + x\\right)$"
      ],
      "text/plain": [
       "6*x*(-a + x)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 3 a x^{2} - 3 a \\left(2 - x\\right)^{2} + 2 x^{3} + 2 \\left(2 - x\\right)^{3} + 2$"
      ],
      "text/plain": [
       "-3*a*x**2 - 3*a*(2 - x)**2 + 2*x**3 + 2*(2 - x)**3 + 2"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,2-x)+expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 6 a x^{2} + 12 a x - 12 a + 12 x^{2} - 24 x + 18$"
      ],
      "text/plain": [
       "-6*a*x**2 + 12*a*x - 12*a + 12*x**2 - 24*x + 18"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 12 a + x^{2} \\cdot \\left(12 - 6 a\\right) + x \\left(12 a - 24\\right) + 18$"
      ],
      "text/plain": [
       "-12*a + x**2*(12 - 6*a) + x*(12*a - 24) + 18"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collect(_,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha,beta =symbols(\"alpha,beta\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "data={tan(alpha)+tan(beta):4,tan(alpha)*tan(beta):sqrt(2)+1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{tan(alpha) + tan(beta): 4, tan(alpha)*tan(beta): 1 + sqrt(2)}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 2 \\sqrt{2}$"
      ],
      "text/plain": [
       "-2*sqrt(2)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_trig(tan(alpha+beta)).subs(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2 \\sqrt{2}}{3}$"
      ],
      "text/plain": [
       "-2*sqrt(2)/3"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin(atan(_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(exp(x)+2*sin(x))/(1+x**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{e^{x} + 2 \\sin{\\left(x \\right)}}{x^{2} + 1}$"
      ],
      "text/plain": [
       "(exp(x) + 2*sin(x))/(x**2 + 1)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=function_tangent(expr,x,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "O=Point(0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,=Intersection(l,Line(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "B,=Intersection(l,Line(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{6}$"
      ],
      "text/plain": [
       "1/6"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Triangle(O,A,B).area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=-x**2+(exp(x)-exp(-x))*sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - x^{2} + \\left(e^{x} - e^{- x}\\right) \\sin{\\left(x \\right)}$"
      ],
      "text/plain": [
       "-x**2 + (exp(x) - exp(-x))*sin(x)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x787b4e7af9d0>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,-2.8,2.8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "eq=Eq(cos(x)/(cos(x)-sin(x)),sqrt(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\cos{\\left(x \\right)}}{- \\sin{\\left(x \\right)} + \\cos{\\left(x \\right)}} = \\sqrt{3}$"
      ],
      "text/plain": [
       "Eq(cos(x)/(-sin(x) + cos(x)), sqrt(3))"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(\\mathbb{R} \\cap \\left\\{- i \\left(i \\left(2 n \\pi - \\operatorname{atan}{\\left(\\frac{\\sin{\\left(\\frac{\\operatorname{atan}{\\left(- \\frac{12}{-2 + 4 \\sqrt{3}} + \\frac{4 \\sqrt{3}}{-2 + 4 \\sqrt{3}} \\right)}}{2} \\right)}}{\\cos{\\left(\\frac{\\operatorname{atan}{\\left(- \\frac{12}{-2 + 4 \\sqrt{3}} + \\frac{4 \\sqrt{3}}{-2 + 4 \\sqrt{3}} \\right)}}{2} \\right)}} \\right)}\\right) + \\log{\\left(\\sqrt{\\sqrt{\\frac{4 \\left(1 - 2 \\sqrt{3}\\right)^{2}}{\\left(1 + \\left(1 - 2 \\sqrt{3}\\right)^{2}\\right)^{2}} + \\left(- \\frac{1}{1 + \\left(1 - 2 \\sqrt{3}\\right)^{2}} + \\frac{\\left(1 - 2 \\sqrt{3}\\right)^{2}}{1 + \\left(1 - 2 \\sqrt{3}\\right)^{2}}\\right)^{2}} \\sin^{2}{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{1}{- 4 \\sqrt{3} \\left(1 - 2 \\sqrt{3}\\right)^{2} - 4 \\sqrt{3} + 2 + 2 \\left(1 - 2 \\sqrt{3}\\right)^{2}} - \\frac{\\left(1 - 2 \\sqrt{3}\\right)^{4}}{- 4 \\sqrt{3} \\left(1 - 2 \\sqrt{3}\\right)^{2} - 4 \\sqrt{3} + 2 + 2 \\left(1 - 2 \\sqrt{3}\\right)^{2}} \\right)}}{2} \\right)} + \\sqrt{\\frac{4 \\left(1 - 2 \\sqrt{3}\\right)^{2}}{\\left(1 + \\left(1 - 2 \\sqrt{3}\\right)^{2}\\right)^{2}} + \\left(- \\frac{1}{1 + \\left(1 - 2 \\sqrt{3}\\right)^{2}} + \\frac{\\left(1 - 2 \\sqrt{3}\\right)^{2}}{1 + \\left(1 - 2 \\sqrt{3}\\right)^{2}}\\right)^{2}} \\cos^{2}{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{1}{- 4 \\sqrt{3} \\left(1 - 2 \\sqrt{3}\\right)^{2} - 4 \\sqrt{3} + 2 + 2 \\left(1 - 2 \\sqrt{3}\\right)^{2}} - \\frac{\\left(1 - 2 \\sqrt{3}\\right)^{4}}{- 4 \\sqrt{3} \\left(1 - 2 \\sqrt{3}\\right)^{2} - 4 \\sqrt{3} + 2 + 2 \\left(1 - 2 \\sqrt{3}\\right)^{2}} \\right)}}{2} \\right)}} \\right)}\\right)\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\}\\right) \\cup \\left(\\mathbb{R} \\cap \\left\\{- i \\left(i \\left(2 n \\pi - \\pi - \\operatorname{atan}{\\left(\\frac{\\sin{\\left(\\frac{\\operatorname{atan}{\\left(- \\frac{12}{-2 + 4 \\sqrt{3}} + \\frac{4 \\sqrt{3}}{-2 + 4 \\sqrt{3}} \\right)}}{2} \\right)}}{\\cos{\\left(\\frac{\\operatorname{atan}{\\left(- \\frac{12}{-2 + 4 \\sqrt{3}} + \\frac{4 \\sqrt{3}}{-2 + 4 \\sqrt{3}} \\right)}}{2} \\right)}} \\right)}\\right) + \\log{\\left(\\sqrt{\\sqrt{\\frac{4 \\left(1 - 2 \\sqrt{3}\\right)^{2}}{\\left(1 + \\left(1 - 2 \\sqrt{3}\\right)^{2}\\right)^{2}} + \\left(- \\frac{1}{1 + \\left(1 - 2 \\sqrt{3}\\right)^{2}} + \\frac{\\left(1 - 2 \\sqrt{3}\\right)^{2}}{1 + \\left(1 - 2 \\sqrt{3}\\right)^{2}}\\right)^{2}} \\sin^{2}{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{1}{- 4 \\sqrt{3} \\left(1 - 2 \\sqrt{3}\\right)^{2} - 4 \\sqrt{3} + 2 + 2 \\left(1 - 2 \\sqrt{3}\\right)^{2}} - \\frac{\\left(1 - 2 \\sqrt{3}\\right)^{4}}{- 4 \\sqrt{3} \\left(1 - 2 \\sqrt{3}\\right)^{2} - 4 \\sqrt{3} + 2 + 2 \\left(1 - 2 \\sqrt{3}\\right)^{2}} \\right)}}{2} \\right)} + \\sqrt{\\frac{4 \\left(1 - 2 \\sqrt{3}\\right)^{2}}{\\left(1 + \\left(1 - 2 \\sqrt{3}\\right)^{2}\\right)^{2}} + \\left(- \\frac{1}{1 + \\left(1 - 2 \\sqrt{3}\\right)^{2}} + \\frac{\\left(1 - 2 \\sqrt{3}\\right)^{2}}{1 + \\left(1 - 2 \\sqrt{3}\\right)^{2}}\\right)^{2}} \\cos^{2}{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{1}{- 4 \\sqrt{3} \\left(1 - 2 \\sqrt{3}\\right)^{2} - 4 \\sqrt{3} + 2 + 2 \\left(1 - 2 \\sqrt{3}\\right)^{2}} - \\frac{\\left(1 - 2 \\sqrt{3}\\right)^{4}}{- 4 \\sqrt{3} \\left(1 - 2 \\sqrt{3}\\right)^{2} - 4 \\sqrt{3} + 2 + 2 \\left(1 - 2 \\sqrt{3}\\right)^{2}} \\right)}}{2} \\right)}} \\right)}\\right)\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\}\\right)$"
      ],
      "text/plain": [
       "Union(Intersection(ImageSet(Lambda(_n, -I*(I*(2*_n*pi - atan(sin(atan(-12/(-2 + 4*sqrt(3)) + 4*sqrt(3)/(-2 + 4*sqrt(3)))/2)/cos(atan(-12/(-2 + 4*sqrt(3)) + 4*sqrt(3)/(-2 + 4*sqrt(3)))/2))) + log(sqrt(sqrt(4*(1 - 2*sqrt(3))**2/(1 + (1 - 2*sqrt(3))**2)**2 + (-1/(1 + (1 - 2*sqrt(3))**2) + (1 - 2*sqrt(3))**2/(1 + (1 - 2*sqrt(3))**2))**2)*sin(atan(1/(-4*sqrt(3)*(1 - 2*sqrt(3))**2 - 4*sqrt(3) + 2 + 2*(1 - 2*sqrt(3))**2) - (1 - 2*sqrt(3))**4/(-4*sqrt(3)*(1 - 2*sqrt(3))**2 - 4*sqrt(3) + 2 + 2*(1 - 2*sqrt(3))**2))/2)**2 + sqrt(4*(1 - 2*sqrt(3))**2/(1 + (1 - 2*sqrt(3))**2)**2 + (-1/(1 + (1 - 2*sqrt(3))**2) + (1 - 2*sqrt(3))**2/(1 + (1 - 2*sqrt(3))**2))**2)*cos(atan(1/(-4*sqrt(3)*(1 - 2*sqrt(3))**2 - 4*sqrt(3) + 2 + 2*(1 - 2*sqrt(3))**2) - (1 - 2*sqrt(3))**4/(-4*sqrt(3)*(1 - 2*sqrt(3))**2 - 4*sqrt(3) + 2 + 2*(1 - 2*sqrt(3))**2))/2)**2)))), Integers), Reals), Intersection(ImageSet(Lambda(_n, -I*(I*(2*_n*pi - pi - atan(sin(atan(-12/(-2 + 4*sqrt(3)) + 4*sqrt(3)/(-2 + 4*sqrt(3)))/2)/cos(atan(-12/(-2 + 4*sqrt(3)) + 4*sqrt(3)/(-2 + 4*sqrt(3)))/2))) + log(sqrt(sqrt(4*(1 - 2*sqrt(3))**2/(1 + (1 - 2*sqrt(3))**2)**2 + (-1/(1 + (1 - 2*sqrt(3))**2) + (1 - 2*sqrt(3))**2/(1 + (1 - 2*sqrt(3))**2))**2)*sin(atan(1/(-4*sqrt(3)*(1 - 2*sqrt(3))**2 - 4*sqrt(3) + 2 + 2*(1 - 2*sqrt(3))**2) - (1 - 2*sqrt(3))**4/(-4*sqrt(3)*(1 - 2*sqrt(3))**2 - 4*sqrt(3) + 2 + 2*(1 - 2*sqrt(3))**2))/2)**2 + sqrt(4*(1 - 2*sqrt(3))**2/(1 + (1 - 2*sqrt(3))**2)**2 + (-1/(1 + (1 - 2*sqrt(3))**2) + (1 - 2*sqrt(3))**2/(1 + (1 - 2*sqrt(3))**2))**2)*cos(atan(1/(-4*sqrt(3)*(1 - 2*sqrt(3))**2 - 4*sqrt(3) + 2 + 2*(1 - 2*sqrt(3))**2) - (1 - 2*sqrt(3))**4/(-4*sqrt(3)*(1 - 2*sqrt(3))**2 - 4*sqrt(3) + 2 + 2*(1 - 2*sqrt(3))**2))/2)**2)))), Integers), Reals))"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(eq,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathbb{R} \\cap \\left\\{2 n \\pi - \\frac{\\operatorname{atan}{\\left(\\frac{6}{11} - \\frac{10 \\sqrt{3}}{11} \\right)}}{2} + i \\left(- \\frac{\\log{\\left(61 - 28 \\sqrt{3} \\right)}}{4} + \\frac{\\log{\\left(7 - 2 \\sqrt{3} \\right)}}{2}\\right)\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\}$"
      ],
      "text/plain": [
       "Intersection(ImageSet(Lambda(_n, 2*_n*pi - atan(6/11 - 10*sqrt(3)/11)/2 + I*(-log(61 - 28*sqrt(3))/4 + log(7 - 2*sqrt(3))/2)), Integers), Reals)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(answer.args[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\operatorname{atan}{\\left(\\frac{6}{11} - \\frac{10 \\sqrt{3}}{11} \\right)}}{2} + i \\left(- \\frac{\\log{\\left(61 - 28 \\sqrt{3} \\right)}}{4} + \\frac{\\log{\\left(7 - 2 \\sqrt{3} \\right)}}{2}\\right)$"
      ],
      "text/plain": [
       "-atan(6/11 - 10*sqrt(3)/11)/2 + I*(-log(61 - 28*sqrt(3))/4 + log(7 - 2*sqrt(3))/2)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(answer.args[0]).args[1].args[0](0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle i \\log{\\left(\\frac{\\sqrt{7 - 2 \\sqrt{3}}}{\\sqrt[4]{61 - 28 \\sqrt{3}}} \\right)} - \\frac{\\operatorname{atan}{\\left(\\frac{6}{11} - \\frac{10 \\sqrt{3}}{11} \\right)}}{2}$"
      ],
      "text/plain": [
       "I*log(sqrt(7 - 2*sqrt(3))/(61 - 28*sqrt(3))**(1/4)) - atan(6/11 - 10*sqrt(3)/11)/2"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logcombine(check,force=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\operatorname{atan}{\\left(\\frac{6}{11} - \\frac{10 \\sqrt{3}}{11} \\right)}}{2}$"
      ],
      "text/plain": [
       "-atan(6/11 - 10*sqrt(3)/11)/2"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(_.as_real_imag())[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\tan{\\left(- \\frac{\\operatorname{atan}{\\left(\\frac{6}{11} - \\frac{10 \\sqrt{3}}{11} \\right)}}{2} + \\frac{\\pi}{4} \\right)}$"
      ],
      "text/plain": [
       "tan(-atan(6/11 - 10*sqrt(3)/11)/2 + pi/4)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tan(_+pi/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1 - \\tan{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{6}{11} - \\frac{10 \\sqrt{3}}{11} \\right)}}{2} \\right)}}{\\tan{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{6}{11} - \\frac{10 \\sqrt{3}}{11} \\right)}}{2} \\right)} + 1}$"
      ],
      "text/plain": [
       "(1 - tan(atan(6/11 - 10*sqrt(3)/11)/2))/(tan(atan(6/11 - 10*sqrt(3)/11)/2) + 1)"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expand_trig(_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1 - \\tan{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{6}{11} - \\frac{10 \\sqrt{3}}{11} \\right)}}{2} \\right)}}{\\tan{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{6}{11} - \\frac{10 \\sqrt{3}}{11} \\right)}}{2} \\right)} + 1}$"
      ],
      "text/plain": [
       "(1 - tan(atan(6/11 - 10*sqrt(3)/11)/2))/(tan(atan(6/11 - 10*sqrt(3)/11)/2) + 1)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trigsimp(_,force=True).doit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2.46410161513775$"
      ],
      "text/plain": [
       "2.46410161513775"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -1 + 2 \\sqrt{3}$"
      ],
      "text/plain": [
       "-1 + 2*sqrt(3)"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(12)-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2.46410161513775$"
      ],
      "text/plain": [
       "2.46410161513775"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "eq=Eq(1/log(a,8)-1/log(4,a),-5/S(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\log{\\left(a \\right)}}{\\log{\\left(4 \\right)}} + \\frac{\\log{\\left(8 \\right)}}{\\log{\\left(a \\right)}} = - \\frac{5}{2}$"
      ],
      "text/plain": [
       "Eq(-log(a)/log(4) + log(8)/log(a), -5/2)"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\log{\\left(2 \\right)}, 6 \\log{\\left(2 \\right)}\\right\\}$"
      ],
      "text/plain": [
       "{-log(2), 6*log(2)}"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,ln(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=exp(x)-a*x-a**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - a^{3} - a x + e^{x}$"
      ],
      "text/plain": [
       "-a**3 - a*x + exp(x)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg xmlns=\"http://www.w3.org/2000/svg\"\n",
       "            xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n",
       "            width=\"100.0\" height=\"100.0\" viewBox=\"0.828171817154095 0.546453645613141 1.34365636569181 2.06193819415085\"\n",
       "            preserveAspectRatio=\"xMinYMin meet\">\n",
       "            <defs>\n",
       "                <marker id=\"markerCircle\" markerWidth=\"8\" markerHeight=\"8\"\n",
       "                    refx=\"5\" refy=\"5\" markerUnits=\"strokeWidth\">\n",
       "                    <circle cx=\"5\" cy=\"5\" r=\"1.5\" style=\"stroke: none; fill:#000000;\"/>\n",
       "                </marker>\n",
       "                <marker id=\"markerArrow\" markerWidth=\"13\" markerHeight=\"13\" refx=\"2\" refy=\"4\"\n",
       "                       orient=\"auto\" markerUnits=\"strokeWidth\">\n",
       "                    <path d=\"M2,2 L2,6 L6,4\" style=\"fill: #000000;\" />\n",
       "                </marker>\n",
       "                <marker id=\"markerReverseArrow\" markerWidth=\"13\" markerHeight=\"13\" refx=\"6\" refy=\"4\"\n",
       "                       orient=\"auto\" markerUnits=\"strokeWidth\">\n",
       "                    <path d=\"M6,2 L6,6 L2,4\" style=\"fill: #000000;\" />\n",
       "                </marker>\n",
       "            </defs><g transform=\"matrix(1,0,0,-1,0,3.15484548537714)\"><path fill-rule=\"evenodd\" fill=\"#66cc99\" stroke=\"#555555\" stroke-width=\"0.0412387638830171\" opacity=\"0.6\" d=\"M 1.00000000000000,0.718281828459045 L 2.00000000000000,2.43656365691809\" marker-start=\"url(#markerReverseArrow)\" marker-end=\"url(#markerArrow)\"/></g></svg>"
      ],
      "text/latex": [
       "$\\displaystyle \\operatorname{Line2D}\\left(\\operatorname{Point2D}\\left(1, -2 + e\\right), \\operatorname{Point2D}\\left(2, -3 + 2 e\\right)\\right)$"
      ],
      "text/plain": [
       "Line2D(Point2D(1, -2 + E), Point2D(2, -3 + 2*E))"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_tangent(expr.subs(a,1),x,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x \\left(1 - e\\right) + y + 1$"
      ],
      "text/plain": [
       "x*(1 - E) + y + 1"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - a + e^{x}$"
      ],
      "text/plain": [
       "-a + exp(x)"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{i \\left(2 n \\pi + \\arg{\\left(a \\right)}\\right) + \\log{\\left(\\left|{a}\\right| \\right)}\\; \\middle|\\; n \\in \\mathbb{Z}\\right\\}$"
      ],
      "text/plain": [
       "ImageSet(Lambda(_n, I*(2*_n*pi + arg(a)) + log(Abs(a))), Integers)"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a$"
      ],
      "text/plain": [
       "a"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(expr,x,2).subs(x,ln(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - a \\left(a^{2} + \\log{\\left(a \\right)} - 1\\right)$"
      ],
      "text/plain": [
       "-a*(a**2 + log(a) - 1)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(expr.subs(x,ln(a)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=symbols(\"a\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(1-a*x)*ln(1+x)-x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - x + \\left(- a x + 1\\right) \\log{\\left(x + 1 \\right)}$"
      ],
      "text/plain": [
       "-x + (-a*x + 1)*log(x + 1)"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnUAAAHTCAYAAABBWu46AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABApklEQVR4nO3dd3zV5cH+8etknayTk4QskrCRGUCWDAcuQEVFO9RW0dpqtWpr1ccWWx/X87h+1lqtYl2PtnVbcXUotAIO9kYiO4GEJIyMk32Sc87390cGGxIg5z7j8369zivkcCJXbkO4cn+/933bLMuyBAAAgKAWYToAAAAAThylDgAAIARQ6gAAAEIApQ4AACAEUOoAAABCAKUOAAAgBFDqAAAAQgClDgBwUliWperqarH9KWAGpQ4AcFLU1NTI6XSqpqbGdBQgLFHqAAAAQgClDgAAIARQ6gAAAEIApQ4AACAEUOoAAABCAKUOAAAgBFDqAAAAQgClDgAAIARQ6gAAAEIApQ4AACAEUOoAAABCAKUOAAAgBFDqAAAAQgClDgAAIARQ6gAAAEIApQ4AACAEUOoAAABCQJTpAAcrczVq1Y5KJdijdNaAdNNxAAAAgkLAzdR9vWWvfvbGSr34xTbTUQAAAIJGwJW67OQ4SVJJVYPhJAAAAMEj4EpdTmup21nVIMuyDKcBAAAIDgFX6jKddtlsktvjU3ldk+k4AAAAQSHgSp09KlLpiXZJXIIFAADoqIArdZKUk8J9dQAAAJ0RkKUuu/2+ukbDSQAAAIJDQJa6HFbAAgAAdEpAlrpsZ6wkSh0AAEBHBWap229bEwAAABxbQJc6ZuoAAAA6JiBLXW7r6te9tU1qbPYaTgMAABD4ArLUOeOiFR8TKUkqdbECFgAA4FgCstTZbDYuwQIAAHRCQJY6icUSAAAAnRGwpS4nuWVbk52VlDoAAIBjCdhSl+3k8isAAEBHBW6pa7unzkWpAwAAOJaALXU5KW0zdax+BQAAOJbALXX7LZSwLMtwGgAAgMAWsKUuMylWNpvU5PGpvK7JdBwAAICAFrClLiYqQhkOuyQWSwAAABxLwJY6ab+96tjWBAAA4KiCo9QxUwcAAHBUAV3qcpNZAQsAANARAV3qOP8VAACgY4Kj1LEBMQAAwFEFeKlrOf+VmToAAICjC+hS17YB8d7aJjU2ew2nAQAACFwBXeqccdGKj4mUxGwdAADA0QR0qbPZbO2zdayABQAAOLKALnUSK2ABAAA6ImhKHRsQAwAAHFnAl7ocVsACAAAcU8CXOvaqAwAAOLbgKXUslAAAADiigC91OfvdU+fzWYbTAAAABKaAL3VZzljZbFKTx6fyuibTcQAAAAJSwJe66MgIZTpYLAEAAHA0AV/qJM6ABQAAOJYgKXXsVQcAAHA0QVHqOCoMAADg6IKi1O2bqas3nAQAACAwBUWpY6YOAADg6IKi1O3bgJh76gAAAA4nKEpd20xdeV2TGpu9htMAAAAEnqAodUlxUUqIiZTEbB0AAMDhBEWps9lsnAELAABwFEFR6iTuqwMAADiaoCt1xZQ6AACAQwRNqctNYaYOAADgSIKm1HH+KwAAwJEFT6lzMlMHAABwJMFT6toWSrga5fNZhtMAAAAElqApdVnOWNlsUpPHp/K6JtNxAAAAAkrQlLroyAhlOrivDgAA4HCCptRJUk7rCtidlDoAAIADBFWpYwNiAPCPRx99VDabTb/85S9NRwHQQUFW6louvzJTBwBdZ9myZXrxxRc1fPhw01EAdEJQlbocZuoAoEvV1tbq6quv1ksvvaSUlBTTcQB0QlCVun171TUaTgIAoenWW2/VtGnTdP755x/ztW63W9XV1Qc8AJgTZTpAZ3BPHQB0nbffflsrV67UsmXLOvT6Rx99VA8++GAXpwLQUUE1U9d2+bW8rkmNzV7DaQAgdBQVFen222/X66+/rtjY2A59zD333COXy9X+KCoq6uKUAI4mqGbqkuKilGiPUq3bo51VDeqXnmg6EgCEhBUrVmj37t0aPXp0+3Ner1dffPGFnn32WbndbkVGRh7wMXa7XXa73d9RARxBUJU6m82m7ORYbdpVqxJKHQCcNOedd57WrVt3wHPXX3+9Bg0apF//+teHFDoAgSeoSp3Ucl9dW6kDAJwcDodDeXl5BzyXkJCgbt26HfI8gMAUVPfUSfsWS+xkBSwAAEC7oJupY686APCP+fPnm44AoBOCcKauZVUWpQ4AAGCfoCt1OcnxkjgqDAAAYH9BV+raZupKqxrl81mG0wAAAASGoCt1mUmxirBJTV6f9ta5TccBAAAICEFX6qIjI5SZ1HZfHStgAQAApCAsdRJnwAIAABwsqEtdcWW94SQAAACBIShL3SkZLceDbSitMZwEAAAgMARlqRuanSRJ+qbEZTgJAABAYAjKUpeX45Qkbdldq4Ymr+E0AAAA5gVlqctw2JWWaJfPkjaUVZuOAwAAYFxQljqbzaa8nLZLsJQ6AACAoCx10r776tbv5L46AACAoC11edkt99WxWAIAACCYS13rYolNZbVq8vgMpwEAADAraEtdbkqckmKj1OT1afNu9qsDAADhLWhLXctiiZbZuvU7WSwBAADCW9CWOolNiAEAANoEdalrn6ljWxMAABDmgrrUDW1dAZtfUi2vzzKcBgAAwJygLnV90hIUHxOphmavCvbWmo4DAABgTFCXusgImwZ3b72vjsUSAAAgjAV1qZOkvLaTJVgsAQAAwljQl7qhrYslmKkDAADhLOhL3f7HhVkWiyUAAEB4CvpSd0pmomIiI1TT6FFRRYPpOAAAAEYEfamLjozQwCyHJDYhBgAA4SvoS50k5eWwWAIAAIS3kCh1bZsQs1gCAACEq5AodXntK2BZLAEAAMJTSJS6QVkORUbYVF7XpF3VbtNxAAAA/C4kSl1sdKT6pydK4r46AAAQnkKi1EnS0ByOCwMAAOErZErd/psQAwAAhJvQKXWtiyXW76TUAQCA8BMypW5w95YNiEtcjaqoazKcBgAAwL9CptQ5YqPVJy1BEoslAABA+AmZUidJQ7NZLAEAAMJTSJW69k2ImakDAABhJrRKXTaLJQAAQHgKqVLXdvm1sLxeNY3NhtMAAAD4T0iVupSEGOUkx0mS8ku4rw4AAISPkCp10n6LJSh1AAAgjIRcqWMTYgAAEI5CrtS1zdStZ6YOAACEkZArdW0zdZt316ihyWs4DQAAgH+EXKnLcNiVlmiXz5I2lDFbBwAAwkPIlTqbzabhuS2zdSu2VxpOAwAA4B8hV+okaXzfVEnS4m3lhpMAAAD4R0iWugl90yRJS7ZVyOP1GU4DAADQ9UKy1A3JTlJSbJRq3B5WwQIAgLAQkqUuMsKmcX27SZIWbuUSLAAACH0hWeokaWK/llK3iPvqAABAGAjhUtdyX92yggo1ebivDgAAhLaQLXUDMhPVLSFGDc1erSmuMh0HAACgS4VsqbPZbBrfdgmW++oAAECIC9lSJ0kT2hdL7DWcBAAAoGuFdKlrWyyxckeVGps5BxYAAISukC51fdISlJUUqyaPTys5MgwAAISwkC51NptNE/qxXx0AAAh9IV3qJLWXOvarAwAAoSz0S13rYok1RVWqc3sMpwEAAOgaIV/qeqTGq0dqnDw+S8sKK0zHAQAA6BIhX+qkfbN17FcHAABCVViUurYjw1gsAQAAQlVYlLq2xRLrS1xy1TcbTgMAAHDyhUWpy0yKVd/0BPksaUkBs3UAACD0hEWpk/adLsHWJgAAIBSFTamb0LflvjoWSwAAgFAUNqVufN9USdKGshqV17oNpwEAADi5wqbUdUu0a1CWQ5K0eBv71QHA/p5//nkNHz5cSUlJSkpK0oQJE/Svf/3LdCwAnRA2pU7SfufA7jWcBAACS25urh577DEtX75cy5cv17nnnqvp06dr/fr1pqMB6KCwKnXsVwcAh3fJJZfooosu0oABAzRgwAA9/PDDSkxM1OLFi01HA9BBUaYD+NO4vqmKirCpYG+dCvbWqU9agulIABBwvF6v3nvvPdXV1WnChAlHfJ3b7Zbbve8e5erqan/EA3AEYTVTlxQbrfGtR4bNzS8znAYAAsu6deuUmJgou92um2++WR988IGGDBlyxNc/+uijcjqd7Y8ePXr4MS2Ag4VVqZOkKUMzJUlz1u8ynAQAAsvAgQO1evVqLV68WD/72c903XXXKT8//4ivv+eee+RyudofRUVFfkwL4GA2y7Is0yH8qaSqQRMf+1w2m7T0N+cr3WE3HQkAAtL555+vfv366YUXXujQ66urq+V0OuVyuZSUlNTF6QAcLOxm6rKT4zQ81ynLkj7fwGwdAByJZVkH3DMHILCFXamTpMmDuQQLAPv7zW9+oy+//FKFhYVat26dfvvb32r+/Pm6+uqrTUcD0EFhWeqmDM2SJH25Za/q3B7DaQDAvF27dmnGjBkaOHCgzjvvPC1ZskSffvqpJk+ebDoagA4Kqy1N2gzITFSvbvHaXl6vLzbt0YXDupuOBABGvfLKK6YjADhBYTlTZ7PZNGVIyyXYuflcggUAAMEvLEudJE0e0nIJ9j8bdqvZ6zOcBgAA4MSEbakb3StFqQkxcjU0a1lBhek4AAAAJyRsS11khE3nD86QJM3hEiwAAAhyYVvqJGlK6yXYufm7FGZ7MAMAgBAT1qXujFPSFBcdqZ1VDVpfwkHUAAAgeIV1qYuNjtRZA9IkcQkWAAAEt7AuddK+S7Bz1pcZTgIAAHD8wr7UnTsoQ5ERNm0oq1FRRb3pOAAAAMcl7EtdSkKMxvZOkcQlWAAAELzCvtRJXIIFAADBj1InaXLrkWHLCitUUddkOA0AAEDnUeok9UiN15DuSfJZ0ucbdpuOAwAA0GmUulZts3VcggUAAMGIUtdqytCWUrdg0x5VNzYbTgMAANA5lLpWQ7onqX9Gotwenz5dx2wdAAAILpS6VjabTd8ZlSNJen9lseE0AAAAnUOp28/lI3Nks0lLCirYiBgAAAQVSt1+ujvjdHq/lrNgP1y103AaAACAjqPUHaTtEuzsVTtlWZbhNAAAAB1DqTvI1KFZio+JVMHeOq0qqjIdBwAAoEModQdJsEfpgryWY8PeX8GCCQAAEBwodYfx3VG5kqRP1pTI7fEaTgMAAHBslLrDGN+3m7o7Y1Xd6NHn33JsGAAACHyUusOIjLDpspFte9axChYAAAQ+St0RfKe11M3fuFvltW7DaQAAAI6OUncEp2Q6NDzXKY/P0idrSkzHAQAAOCpK3VG0zdbNZiNiAAAQ4Ch1R3HJiGxFRdi0ttilzbtqTMcBAAA4IkrdUXRLtOvsgRmSmK0DAACBjVJ3DN9tPTbsw1U75fVxbBgAAAhMlLpjOHdwhpJio1TqatTibeWm4wAAABwWpe4Y7FGRumREtiTp/ZUcGwYAAAITpa4DvtN6bNi/1pXJVd9sOA0AAMChKHUdMKpnsgZlOdTQ7NV7K4pMxwGAds3NzSoqKtLGjRtVUVFhOg4Agyh1HWCz2XTthN6SpL8u3i4fCyYAGFRbW6sXXnhBZ599tpxOp3r37q0hQ4YoPT1dvXr10o033qhly5aZjgnAzyh1HXTZyGwlxUZpe3m9FmzaYzoOgDD11FNPqXfv3nrppZd07rnnavbs2Vq9erU2btyoRYsW6f7775fH49HkyZN1wQUXaPPmzaYjA/ATm2VZTDt10P/+PV8vf1Wgswem67XrTzMdB0AY+v73v6/77rtPw4YNO+rr3G63XnnlFcXExOiGG27wS7bq6mo5nU65XC4lJSX55c8EsA+lrhMK99bpnCfny7Kk+f91tnqnJZiOBCCM1dTUyOFwmI7RjlIHmMXl107onZagswekS2q5tw4ATDrzzDNVVlZmOgaAAEGp66RrJ/aWJL27vEh1bo/ZMADC2pgxYzRu3Dht2LDhgOdXrVqliy66yFAqAKZQ6jpp0inp6t0tXjWNHn24mvNgAZjz8ssv68c//rHOOOMMffXVV9q0aZOuuOIKjRkzRna73XQ8AH5GqeukiAibZrRub/KXhdvFLYkATLr//vt11113afLkycrLy1NDQ4OWLVumDz74wHQ0AH5GqTsO3xudq7joSG3cVaMlBWz2CcCM0tJS/eIXv9D//M//aMiQIYqOjtZVV12lUaNGmY4GwABK3XFwxkXr8lE5kqQ/Lyw0GwZA2Orbt6++/PJLvffee1qxYoVmz56tW265RY8//rjpaAAMoNQdp+taL8HOyd+lkqoGs2EAhKVXX31Vq1at0rRp0yRJU6dO1bx58/T000/rlltuMZwOgL9R6o7TwCyHxvdNlddn6c0lO0zHARCGrrrqqkOeGzVqlBYuXKj58+f7PxAAoyh1J6Bttu6tpTvk9njNhgGAVr1799bXX39tOgYAP6PUnYDJQzLV3Rmr8rom/WNtqek4AMLAjh0duzKQkpIiSdq5k62XgHBBqTsBUZERumZ8L0nSawsL2d4EQJcbO3asbrzxRi1duvSIr3G5XHrppZeUl5en2bNn+zEdAJOiTAcIdleO7aFn/rNZa4tdWrS1XBP7p5mOBCCETZ8+XQ6HQxdccIGio6M1ZswYZWdnKzY2VpWVlcrPz9f69es1ZswYPfHEE7rwwgtNRwbgJzaL6aUTdv9H3+jPi7ZrQt9ueuun403HARDCYmJiVFRUpKSkJGVmZuqKK65QeXm5GhoalJaWppEjR2rq1KnKy8vze7bq6mo5nU65XC4lJSX5/c8Hwh0zdSfBTyf105tLd2jRtnKt2F6h0b1STUcCEKJycnK0atUqXXDBBaqtrdUjjzyijIwM07EABADuqTsJcpLj9J2RuZKkZz/fYjgNgFD2X//1X7r00ks1ceJE2Ww2vfHGG1q2bJkaGtgvEwh3XH49SQr31uncJ+fLZ0l///kZystxmo4EIEStX79eH330ke6991717dtXhYWFstls6t+/v0aMGKFTTz1VI0aM8Pv9dFx+Bcyi1J1Et7+9Sh+tLtGFeVl6/prRpuMACHH9+/fX4sWLlZCQoLVr12r16tXtj2+++UY1NTV+zUOpA8yi1J1Em3bVaMpTX8hmk+b88iydkukwHQlAmLIsSzabza9/JqUOMIt76k6iAZkOTR2aKcuSZs3fajoOgDDm70IHwDxK3Ul22zmnSJI+XlOi7eV1htMAAIBwQak7yYblOjVpQLq8Pkt/WsBsHQAA8A9KXRf4+bn9JUl/W1GsUhfbDAAAgK5HqesCY3qnalyfVDV7Lb2wYJvpOAAAIAxQ6rrIz89tubfu7WU7tKfGbTgNAAAIdZS6LnJ6/24a0SNZjc0+vfJVgek4AAAgxFHquojNZtPPz2m5t+6viwpVVd9kOBEAAAhllLoudN7gDA3KcqiuyavXFhaajgMAAEIYpa4L2Ww23da6Evb/viqQq77ZcCIAABCqKHVd7MK87hqY6VB1o0fPzd9iOg4AAAhRlLouFhlh08yLBkmSXvu6UEUV9YYTAQCAUESp84OzB6RrYr9uavL69OScjabjAACAEESp8wObzabfXDRYkvTh6hKtK3YZTgQAB3r00Uc1duxYORwOZWRk6LLLLtPGjfwQCgQTSp2f5OU4dfnIHEnSI//8VpZlGU4EAPssWLBAt956qxYvXqy5c+fK4/FoypQpqqurMx0NQAfZLNqF3xRX1uvcJxeoyePTqz8aq3MGZZiOBACHtWfPHmVkZGjBggU666yzOvQx1dXVcjqdcrlcSkpK6uKEAA7GTJ0f5abE6/qJvSVJj/7rW3m8PrOBAOAIXK6W20RSU1OP+Bq3263q6uoDHgDModT52S1n95czLlqbdtXq/ZXFpuMAwCEsy9Kdd96pM844Q3l5eUd83aOPPiqn09n+6NGjhx9TAjgYpc7PnPHR+nnrhsRPztmk+iaP4UQAcKDbbrtNa9eu1VtvvXXU191zzz1yuVztj6KiIj8lBHA4lDoDZkzopR6pcdpd49bLXxaYjgMA7X7+85/r448/1rx585Sbm3vU19rtdiUlJR3wAGAOpc4Ae1Sk7p7asiHxCwu2ak+N23AiAOHOsizddtttmj17tj7//HP16dPHdCQAnUSpM+TiYd01Itepuiavnv7PJtNxAIS5W2+9Va+//rrefPNNORwOlZWVqaysTA0NDaajAeggtjQxaPG2cl314mJFRtj02S/PUv+MRNORAIQpm8122OdfffVV/ehHP+rQf4MtTQCzmKkzaHzfbjp/cIa8Pkv/79MNpuMACGOWZR320dFCB8A8Sp1hMy8cpAibNCd/l5YWVJiOAwAAghSlzrD+GQ5dObanJOmhv69nQ2IAAHBcKHUB4M7JA5QUG6Vvdlbrr4u3m44DAACCEKUuAKQ77Pr1hS1bnDw5Z5PKXI2GEwEAgGBDqQsQPxjbUyN7JqvW7dFDf19vOg4AAAgylLoAERFh08OXDVNkhE3/XFemeRt2m44EAACCCKUugAzJTtKPT+8tSfrvj75RQ5PXbCAAABA0KHUB5pfnD1C2M1bFlQ165vPNpuMAAIAgQakLMAn2KD04PU+S9NIX27SxrMZwIgAAEAwodQFo8pBMTR6SKY/P0r0frpPPx0luAADg6Ch1AerBS4cqPiZSywor9d6KItNxAABAgKPUBajs5DjdOXmAJOnRf21Qea3bcCIAABDIKHUB7EcTe2tw9yRV1TfrkX9uMB0HAAAEMEpdAIuKjNAjl+fJZpPeX1msRVvLTUcCAAABilIX4Eb2TNHV43pKkn774Tq5PexdBwAADkWpCwJ3Tx2ktES7tu2p0+/nbjIdBwAABCBKXRBwxkXrkctb9q578YttWlpQYTgRAAAINJS6IDFlaJauGJMry5LufHe1ahqbTUcCAAABhFIXRO67ZKh6pMapuLJBD32SbzoOAAAIIJS6IJJoj9KT3z9VNpv03opifba+zHQkAAAQICh1Qea0Pqm66ax+kqR7Zq/Tnho2JQYAAJS6oHTH5FM0KMuhiromzXx/rSyLs2EBAAh3lLogZI+K1B+uOlUxkRH6z4bdemcZZ8MCABDuKHVBalBWku6eOlCS9NDf87W9vM5wIgAAYBKlLoj95Iw+GtcnVfVNXt357hp5fVyGBQAgXFHqglhEhE1PXjFCifYordheqT8t2Go6EgAAMIRSF+RyU+L1wKVDJUlPzd2kb3a6DCcCAAAmUOpCwHdH5eiCoVny+Czd8c5qNTZ7TUcCAAB+RqkLATabTY98Z5jSEu3avLtWj/zzW9ORAACAn1HqQkRqQoye+P5wSdJfFm3XR6t3Gk4EAAD8iVIXQs4ZmKHbzukvSZr5/jptLKsxnAgAAPgLpS7E3DF5gM7on6aGZq9+9voK1TQ2m44EAAD8gFIXYiIjbHr6qlOV7YzVtr11uvs9jhEDACAcUOpCULdEu567epSiI236dH2ZXv6ywHQkAADQxSh1IWpkzxTdd0nL/nWPfbpBS7aVG04EAAC6EqUuhF0zrqcuH5kjr8/SrW+u0u7qRtORAABAF6HUhTCbzaZHLh+mQVkO7a1169Y3V6rZ6zMdCwAAdAFKXYiLi4nU89eMlsMepWWFlXr8XxtMRwIAAF2AUhcG+qQl6HdXjJAkvfxVgf6xttRwIgAAcLJR6sLE1KFZumlSX0nSr/62Rlt21xpOBAAATiZKXRi5e8pATejbTXVNXt38+grVuj2mIwEAgJOEUhdGoiIj9MwPRiozya4tu2t16xsr5WHhBAAAIYFSF2bSHXa9dO0YxUVHasGmPbrv4/WcOAEAQAig1IWh4bnJevqqU2WzSW8u2aEXv9hmOhIAADhBlLowNWVolv572hBJ0qP/2sCKWAAAghylLoz9+Iw++tHE3pKkO95drRXbK80GAgAAx41SF+b+++IhOn9wppo8Pt34l+XaXl5nOhIAADgOlLowFxlh0zM/OFXDcpyqqGvS9a8uU1V9k+lYAACgkyh1UHxMlF65boxykuO0bW+dfvqXFXJ7vKZjAQCATqDUQZKUkRSrV68fK4c9SksLK/Srv61lqxMAAIIIpQ7tBmQ69Pw1oxUVYdNHq0v01NxNpiMBAIAOotThAGeckqZHLh8mSXrm8y16d3mR4UQAAKAjKHU4xBVje+i2c/pLkn4ze50WbNpjOBEAADgWSh0O664pAzT91Gx5fJZu+utyLS2oMB0JAAAcBaUOh2Wz2fTE90bonIHpamz26cevLdPa4irTsQAAwBFQ6nBEMVERev6a0RrfN1W1bo+u/b+l2lhWYzoWAAA4DEodjio2OlIvXzdWp/ZIVlV9s655ZYkK9nLqBAAAgYZSh2NKtEfpz9efpkFZDu2pceual5doZ1WD6VgAAGA/lDp0iDM+Wn/9yTj1TUvQzqoGXfPyEu2uaTQdCwAAtKLUocPSHXa9fsM45STHqWBvna59ZSnnxAIAECAodeiU7OQ4vXnjOGU47NpQVqPr/m+pXA3NpmMBABD2KHXotF7dEvT6DeOUEh+tNcUuXfPyElXWMWMHAIBJlDoclwGZDr1xw3ilJsRo3U6XfvDSYu2tdZuOBQBA2KLU4bgNyU7SOz8dr/TWS7FXvbhYu6pZPAEAgAmUOpyQUzIdeuen49XdGastu2t15QuLVMJ2JwAA+B2lDiesb3qi3r1pgnJT4lRYXq8rXlikoop607EAAAgrlDqcFD1S4/XuTRPUu1u8iisbdMULi7RtT63pWAAAhA1KHU6a7OQ4vXvTBPXPSFSpq1FXvrhYm3dxViwAAP5AqcNJlZEUq7d/Or79SLErX1ys9SUu07EAAAh5lDqcdGmJdr390/EaluNURV2TfvDiYq0uqjIdCwCAkEapQ5dIjo/RGzeO06ieyapu9OgHLy7W5xt2mY4F4Ci++OILXXLJJcrOzpbNZtOHH35oOhKATqDUocskxUbrrz8ZpzNPSVNDs1c3/mWF3lm2w3QsAEdQV1enESNG6NlnnzUdBcBxsFmWZZkOgdDW7PVp5vvr9P7KYknS7eedol+ef4psNpvhZACOxGaz6YMPPtBll13W4Y+prq6W0+mUy+VSUlJS14UDcFhRpgMg9EVHRuh33x+u7ORY/fHzLXr6P5tV5mrU/16ep+hIJouBYOV2u+V27zsesLq62mAaAPyLCr+w2Wy6a8pAPXx5niJs0jvLi3TjX5arzu0xHQ3AcXr00UfldDrbHz169DAdCQhrlDr41dXjeumFGWMUGx2h+Rv36AcvLdaeGvexPxBAwLnnnnvkcrnaH0VFRaYjAWGNUge/mzwkU2/eOF4p8dFaW+zSd59fqIK9daZjAegku92upKSkAx4AzKHUwYhRPVP0/s8mqkdqnHZU1Os7s77W4m3lpmMBABC0KHUwpm96omb/7HQNz3Wqsr5Z17y8RK8v3m46FhC2amtrtXr1aq1evVqSVFBQoNWrV2vHDrYiAoIBW5rAuIYmr371/lp9sqZEknTN+J66/5KhrIwF/Gz+/Pk655xzDnn+uuuu02uvvXbMj2dLE8AsSh0CgmVZen7BVj3x2UZZljSuT6qev2a0UhNiTEcD0EGUOsAspkIQEGw2m245u79evnaMEu1RWlJQoUuf/UrflrLvFQAAHUGpQ0A5b3CmPrhlonp1i1dxZYO++/xCffpNqelYAAAEPEodAs4pmQ59dOvpOqN/muqbvLr59ZV6+t+b5fNxpwAAAEdCqUNASo6P0WvXj9X1p/eWJD3170265Y2Vqm5sNhsMAIAARalDwIqKjND9lwzV//vucEVH2vTp+jJd8sev9M1Ol+loAAAEHEodAt4VY3vovZsnKic5TtvL6/Wd5xfqzSU7xMJtAAD2odQhKJzaI1n/+MUZOm9Qhpo8Pv3mg3W6453VqnN7TEcDACAgUOoQNJLjY/TStWM088JBioyw6cPVJZr+3NfatKvGdDQAAIyj1CGoRETYdPOkfnr7p+OVmWTXlt21mv7s13p/RbHpaAAAGEWpQ1Aa2ztV//jFmTqjf5oamr266701uvu9NVyOBQCELUodglZaol1//vFpuuP8AbLZpPdWFGvaM19q1Y5K09EAAPA7zn5FSFi0tVx3vrtapa5GRUbYdPt5p+iWs/spKpKfWwB/4exXwCxKHUKGq75Z9370jT5ZUyJJGt0rRU9dcap6dos3nAwID5Q6wCxKHUKKZVn6aHWJ/vvDb1Tj9ijRHqUHLh2q747Kkc1mMx0PCGmUOsAsSh1CUlFFve56d42WFlZIkqYN666HL89TcnyM4WRA6KLUAWZR6hCyvD5Lf1qwVU/N3SSPz1K6w67/vSxPU4dmmY4GhCRKHWAWpQ4hb12xS3e8u1pbdtdKki4Zka0HLx2q1ARm7YCTiVIHmEWpQ1hobPbqmf9s1gtfbJPXZ6lbQowemp6nacO7m44GhAxKHWAWpQ5hZW1xle5+b602th4tdmFelh6anqd0h91wMiD4UeoAsyh1CDtNHp+enbdFs+ZtkcdnKSU+Wv998RBdPpIVssCJoNQBZlHqELbWl7j0X++t1bel1ZKkCX276X8vz1O/9ETDyYDgRKkDzKLUIaw1e3168YtteuY/m+X2+BQTGaGbJ/XVLef0V2x0pOl4QFCh1AFmUeoASTvK63Xfx99o/sY9kqRe3eL10PQ8TRqQbjgZEDwodYBZlDqglWVZ+vSbMj3wyXrtqnZLkqYN7677Lh6izKRYw+mAwEepA8yi1AEHqXV79Ps5m/TawgL5LCnRHqW7pgzQjPG9FBUZYToeELAodYBZlDrgCL7Z6dJvP/xGa4qqJEmnZCTqvy8eorO4JAscFqUOMItSBxyF12fpraU79OScjaqsb5YknTsoQ7+5aLD6Z7BKFtgfpQ4wi1IHdICrvlnPfL5Zf15YKI/PUlSETTMm9NLt552i5HiOGwMkSh1gGqUO6IRte2r1yD+/1b+/3S1JSo6P1h3nD9APx/VUNPfbIcxR6gCzKHXAcfhy8x79z9/ztWlXrSSpf0aifjttsM4ekM6pFAhblDrALEodcJw8Xp/eXlak38/dpIq6JknSuD6punvqQI3pnWo4HeB/lDrALEodcIJcDc169vPN+vOi7Wry+CRJ5wxM111TBiovx2k4HeA/lDrALEodcJKUVDXoj59v1rvLi+X1tfy1mja8u+6cPIDzZBEWKHWAWZQ64CQr2FunP/x7kz5eUyLLkiJs0ndH5er2809Rbkq86XhAl6HUAWZR6oAu8m1ptZ6cs0n//naXJCk60qarx/XSLef0U4aDY8cQeih1gFmUOqCLrdxRqSfnbNTXW8olSXHRkbp2Qi/95Mw+lDuEFEodYBalDvCTr7fs1ROfbdTq1mPH7FERunJsD/30rL5clkVIoNQBZlHqAD+yLEufb9itZ+dt0aodVZKkqAibpp+ao5+d3Y+jxxDUKHWAWZQ6wADLsrRoW7lmzduqr7bslSTZbNKFeVm65ez+bIWCoESpA8yi1AGGrdpRqVnzt2pu/q72584emK5bzu6vsb1TOKECQYNSB5hFqQMCxMayGj0/f4s+XlOi1m3uNDzXqZ+c0UcXDevO2bIIeJQ6wCxKHRBgtpfX6U8Ltun9lcXtJ1RkJcXq2om99MPTeio5PsZwQuDwKHWAWZQ6IECV17r1xpId+sui7dpb65bUsh3Kd0fn6Men91FfTqlAgKHUAWZR6oAA5/Z49cmaUr3yVYG+La1uf/7cQRm6dkIvnXVKuiIiuO8O5lHqALModUCQaFsx+39fFeg/G3ar7W9uz9R4/XBcT10xpodSE7g0C3ModYBZlDogCG3bU6u/Lt6uv60oVk2jR5IUExWhacO665rxPTWqJ6tm4X+UOsAsSh0QxOqbPPpkTYleX7xD63a62p8flOXQFWN66PKROUph9g5+QqkDzKLUASFiTVGVXl+8XR+vKZG7ddVsTGSEJg/N1JVjeuiM/mnce4cuRakDzKLUASHGVd+sj9bs1DvLirS+ZN/CipzkOH1vdK6+NzpXPVI5axYnH6UOoc5V36xlhRVaWlghn8/SvRcPMR3pAJQ6IIR9s9Old5cX6cNVO1Xdeu+dJJ3WO1WXjczRtGHd5YyPNpgQoYRSh1BTXuvW0oIKLWl9bCirbl+klmiP0ur7JisqgDaGp9QBYaCx2avP1pfp3eVFWri1vP2bUkxkhM4dlKHLRubonEHpskdFmg2KoEapQ7ArqWpomYlrLXFbdtce8pq+aQka1zdVp/VJ1UXDugfU901KHRBmSqoa9PGaEn2wcqc27qppfz4pNkrThmfrkuHddVqf1ID66RPBgVKHYOL1Wdq0q0bLCyu0rLBSywsrVOJqPOR1g7IcOq1PavsjwxFrIG3HUOqAMPZtabU+XLVTH67eqV3V7vbn0xJjNHVolqYN765xfbopkgUW6ABKHQJZY7NXq4uqtLywQsu3V2rF9sr2LaHaREbYlJedpDG9UzWuT6rG9k4Nqh0EKHUA5PVZWrytXJ+sKdGn68tUVd/c/ntpiTG6IC9LFw2j4OHoKHUIFJZlqbiyQSt3VGrVjiqt3FGp/JJqeXwHVp6EmEiN6pWiMb1SNbZ3ik7tmaz4mChDqU8cpQ7AAZq9Pi3aWq5/rC3VZ/kHFzy7zh+coclDMnV6/zTFRgfOvSQwj1IHUxqbvfpmp0srtldq5Y5KrdxRpT017kNel+Gwa2yfVI3tlaIxvVM1KMsRUreaUOoAHFGz16eFW8v1z8MUvLjoSJ15SpomD8nUeYMzOaIMlDr4hc9nqaC8TmuKqrSmqEqri13KL3Gp2XtgnYmKsGlodpJG9kzRqF4pGtUzWTnJcSF92g6lDkCHNHt9WrytXP/O36W5+bsOuKE4wiaN7pWiyUMyde6gTPVLTwjpb5w4PEodusLu6katLqrSmuIqrSlyaU1x1SH3wkktVxJG9UzW6F4tJW5YjjPsriZQ6gB0mmVZWl9SrX9/21Lw9t/kWGrZ6HjSwHSdPSBdE/unKdEevPeooOModThRroZmrd/p0ppiV8tMXHGVSg+zItUeFaFhOU6N6JGsET2SNbJHsnJTQnsWriModQBOWElVQ3vBW7KtQk1eX/vvRUXYNKZ3iiYNyNCkAekalOXguLIQRalDZ7QVuHU7XVq706Vvdrq0vbz+kNdF2KQBmQ6NyE1uLXFODch0KDqE7oU7WSh1AE6q+iaPlmyr0IJNezR/424VHvRNultCjCb066aJ/dI0sV839eoWH/Y/XYcKSh2OZHdNo/JLqrW+pFr5pdVHLHCSlJsS11rgnBqRm6y8HKcSmO3vEEodgC5VuLdOX2zeowUb92jh1nI1NHsP+P1sZ6wmtBa8if27qbszzlBSnChKHXw+S9sr6lsLnEv5pS1F7nArUSWpR2qchuU4lZfjbHmb7QyqfeECDaUOgN80eXxaXVSlhVv3auHWcq3aUXnIirVe3eI1pleqxvRO0djeKeqXnshMXpCg1IUXV32zNpRVa0NZTeujWpvKalTX5D3ktTZby/FaQ7OdGpKdpLxsp/JykpQcT4E7mSh1AIxpaPJq+fYKLdxaroVby7WuuEoH7Q2qlPhojW7dU2pMrxQNy3UG1FmL2IdSF5qaPD5t21urDaX7ytvGsprDLmCQWhYxDMpyaEhrgRuanaRBWY6g3tQ3WFDqAASM6sZmrdxeqeWFlVq+vUKri6rU2Ow74DUxUREanuPUyJ7JGp6brBG5yeqRyqq3QECpC25uj1cFe+u0eVetNu+q0ebdtdq0q0aF5fXyHvzTVquc5DgN7u7QoKwkDcxyaHB3h3p3SwipDX2DCaUOQMBq8vi0vqRll/hlhRVasb1Se2ubDnldSny0huUma0Sus7XoOZWRFLiHbocqSl1wqHV7VLCnTlv31Grrnlpt3lWrTbtrtP0o5c1hj9LALIcGdXdoYFaSBmc5NCDLoaTYaD+nx9FQ6gAEDcuyVFher+WFFVpb7NLa4ip9W1pzwBYqbbKSYpWXk6Qh3ZM0uPXRMzWe7VS6EKUucHh9lkqqGlSwt07b9tRq6546bdtbq62761RWffjLplJLeTslM1GnZDha3mY6NCAzUVlJscyGBwFKHYCg5vZ4tbGsRmuKXVpbVKW1xS5t3l1zyL15Usvh3S2XiPYVvYFZDjZHPkkodf7l81kqcTVoe3m9CvbWqXBvnQrL61Swt05FFQ2H/WGnTVpijPqmJ6pfeoL6pSdqQKZDAzIdykyyU96CGKUOQMipc3ta9sMqcenb0hrll1Zr464aNXkO/49cd2es+mfsNzvR+mtnPJeWOoNSd/LVuj0qqqjXjor69rdtj+JjFLeYyAj17BavvmkJ6peRqH7pieqbnqB+aYl8bYcoSh2AsODx+lSwt075pdXtRe/b0iPvnyW1nCXZNz1BfbolqHdagvqkxatPWqJ6dYsPuzMlO4JS1zmWZam6waOdVQ0tj8p6lbgatbOyQcVVDSquqFd53aH3kO4vKsKmnqnx6p2WoN7dWr5G236dnRynSG43CCuUOgBhzVXfrC17alpW/O1ueWzZVaOSI2zX0CbbGaseqfHqkRqv3JQ49UiJb30/ThmO2LD8x5RSt09bYSurblRZdaN2uRrbf11a1aCSqkbtrGpQrfvQg+kPlhIfrZ6tX2s993v0SI1Xd2csK03RjlIHAIdR6/Zo6+5aFZbXaduelnuVCvfWadveOtU0Hv0f4uhIm3KS45Sb0vKPbndnrDJb32Ylxam7M1bJ8dEhd+9SOJQ6n8+Sq6FZe2vd2lPj1p5at/bWNml3TUtxK3U1aldreTt4O54j6ZYQo+zkOOUkxyknJa791z1S49QjNZ4VpugwSh0AdIJlWaqoa1JhecvN6MWV9SqqaFBRZb2KKxtUUtUgzxG2hdifPSpCWc5YZTpi1S0xRmmJ9paHI0bdEuxKd+x7Lj4m0m8FcNasWXriiSdUWlqqoUOH6g9/+IPOPPPMDn1sMJY6r89SVX2TKuub299W1jepqr5JFXUt5a2twO2tdau8tqlD/3/bJMdHKyspVplJsS1vW8t9TvK+8hYXw6V8nByUOgA4iTxen8qqG1Vc2aDiygbtqm5UqatBZa2zOGWuxmPeJ3Ww2OgIdUuwyxkXreT4loczLlrOuJiW9+Na3nfERivBHilHbJQS7FFKtEcpISaqw9u4vPPOO5oxY4ZmzZql008/XS+88IJefvll5efnq2fPnsf8eH+XOsuy5Pb4VOf2qL7Jq7omj2obPapp9Ki6sVnVjR7VNDaruqH1bev7VfsVuOrGZh3Pv4LOuGiltZVxh10ZDruykmJbinpS6+xsUiz3XsKvKHUA4Gduj1e7q90qqWpouXxX41Z5XVPrjFCTyuv2zQrVH+Yczc5KiIlUYmyU4mOiZI+KUGx0pGKjW97GRUe2v//h+39T9/RuumTahYqOtCkyIkJP/u4JDc8bosunX6qoyAhFRtgUHWlTROvMoc1mk00tZ3s21NbqitMH6r2FGxWbkCivz5JltcyG+ay2h+TxWfJ4fWr2+tTstdTs9cnT+tbt8cnt8aqx2afGZq8am71ye9p+3fK2rsmjenfL205Mmh2VIzZKqQkxSo6PUUp8tFLiWwpzWqJd6Yl2pTsOnEmNieI+NgSeDpU6y7JUU1PjjzwAgP3UN3lUXtukyvomVTd65KpvUnVjs1z1HlU1NMvV0KTqhma5Gjyqc3tU6255W9fkPeLpAF3F567Xzud/pJyfvaYIe7xf/+zY6AglxEQq3h4lhz1ajtgoOWJbZisTY6OVFBulxNb3k+KildI645kcFyNnXDSLDRAUHA7HUW/F6FCpa5tSBwAAgBnHurXByExddXW1evTooaKioqC5mdYUxqrjGKuOY6w6LlzGqrS0VIMGDdLcuXN12mmntT//xBNP6O2339aKFSsO+Ri32y23233Af+O0005Tfn6+cnJy/JI7WIXL19WJYpwOdKyZug6djWOz2bpkMJOSkvif1EGMVccxVh3HWHVcqI9VbGysIiMjVVNTc8DnWV1drezs7E597g6HI6TH6mQK9a+rk4Vx6hhuIgAAKCYmRqNHj9bcuXMPeH7u3LmaOHGioVQAOoNTrAEAkqQ777xTM2bM0JgxYzRhwgS9+OKL2rFjh26++WbT0QB0gJFSZ7fbdf/998tut5v444MKY9VxjFXHMVYdF05jdeWVV6q8vFwPPfSQSktLlZeXp3/+85/q1atXhz6+bYzCYaxOVDh9XZ0Ixqlz2KcOAHBSBOOJEkAo4Z46AACAEECpAwAACAGUOgAAgBBAqQMAAAgBfit1Dz/8sCZOnKj4+HglJyd36GMsy9IDDzyg7OxsxcXF6eyzz9b69eu7NmgAqKys1IwZM+R0OuV0OjVjxgxVVVUd9WNqa2t12223KTc3V3FxcRo8eLCef/55/wQ26HjGSpK+/fZbXXrppXI6nXI4HBo/frx27NjR9YENOt6xanPTTTfJZrPpD3/4Q5dlDASdHafm5mb9+te/1rBhw5SQkKDs7Gxde+21Kikp8V9oP5k1a5b69Omj2NhYjR49Wl9++eVRX79gwQKNHj1asbGx6tu3r/70pz/5Kal5nRmr2bNna/LkyUpPT1dSUpImTJigzz77zI9pzers11Wbr7/+WlFRUTr11FO7NmAwsfzkvvvus37/+99bd955p+V0Ojv0MY899pjlcDis999/31q3bp115ZVXWt27d7eqq6u7NqxhF1xwgZWXl2ctXLjQWrhwoZWXl2ddfPHFR/2YG264werXr581b948q6CgwHrhhResyMhI68MPP/RTajOOZ6y2bNlipaamWnfffbe1cuVKa+vWrdbf//53a9euXX5KbcbxjFWbDz74wBoxYoSVnZ1tPfXUU10b1LDOjlNVVZV1/vnnW++88461YcMGa9GiRda4ceOs0aNH+zF113v77bet6Oho66WXXrLy8/Ot22+/3UpISLC2b9/e/hqXy2VJslwul7Vt2zYrPj7euv322638/HzrpZdesqKjo62//e1vBj8L/+jIWO3v9ttvtx5//HFr6dKl1qZNm6x77rnHio6OtlauXOnn5P7X2bFqU1VVZfXt29eaMmWKNWLECP+EDQJ+K3VtXn311Q6VOp/PZ2VlZVmPPfZY+3ONjY2W0+m0/vSnP3VhQrPy8/MtSdbixYvbn1u0aJElydqwYcMRP27o0KHWQw89dMBzo0aNsu69994uy2ra8Y7VlVdeaV1zzTX+iBgwjnesLMuyiouLrZycHOubb76xevXqFdKl7kTGaX9Lly61JB3zH6Zgctppp1k333zzAc8NGjTImjlzZvv7+5e6X/3qV9agQYMOeP1NN91kjR8/3i95TerIWB3LkCFDrAcffPBkRws4xztWV155pXXvvfda999/P6VuPwF7T11BQYHKyso0ZcqU9ufsdrsmTZqkhQsXGkzWtRYtWiSn06lx48a1Pzd+/Hg5nc6jft5nnHGGPv74Y+3cuVOWZWnevHnatGmTpk6d6o/YRhzPWPl8Pv3jH//QgAEDNHXqVGVkZGjcuHH68MMP/ZTajOP9uvL5fJoxY4buvvtuDR061B9RjTrecTqYy+WSzWbr8K0mga6pqUkrVqw44PuxJE2ZMuWI47Jo0aJDXj916lQtX75czc3NXZbVtOMZq4P5fD7V1NQoNTW1KyIGjOMdq1dffVVbt27V/fff39URg07AlrqysjJJUmZm5gHPZ2Zmtv9eKCorK1NGRsYhz2dkZBz1837mmWc0ZMgQ5ebmKiYmRhdccIFmzZqlM844oyvjGnU8Y7V7927V1tbqscce0wUXXKA5c+bo8ssv13e+8x0tWLCgqyMbc7xfV48//riioqL0i1/8oivjBYzjHaf9NTY2aubMmfrhD38YMhvw7t27V16vt1Pfj8vKyg77eo/Ho71793ZZVtOOZ6wO9uSTT6qurk5XXHFFV0QMGMczVps3b9bMmTP1xhtvKCqKk04PdkKl7oEHHpDNZjvqY/ny5ScU0GazHfC+ZVmHPBcMOjNWh/v8jvV5P/PMM1q8eLE+/vhjrVixQk8++aRuueUW/fvf/+6yz6mrdOVY+Xw+SdL06dN1xx136NRTT9XMmTN18cUXB+VN3F05VitWrNDTTz+t1157LSj/zu2vq//+tWlubtZVV10ln8+nWbNmnfTPw7TOfj8+3OsP93woOt5/u9566y098MADeueddw77A0Yo6uhYeb1e/fCHP9SDDz6oAQMG+CteUDmhmnvbbbfpqquuOuprevfufVz/7aysLEktP+117969/fndu3cf0uqDQUfHau3atdq1a9chv7dnz54jft4NDQ36zW9+ow8++EDTpk2TJA0fPlyrV6/W7373O51//vkn/gn4UVeOVVpamqKiojRkyJADnh88eLC++uqr4w9tSFeO1Zdffqndu3erZ8+e7c95vV7ddddd+sMf/qDCwsITyu5PXTlObZqbm3XFFVeooKBAn3/+ecjM0kktf28iIyMPmT052vfjrKysw74+KipK3bp167Ksph3PWLV555139JOf/ETvvfde0H3fPh6dHauamhotX75cq1at0m233Sap5Qd1y7IUFRWlOXPm6Nxzz/VL9kB1QqUuLS1NaWlpJyvLAfr06aOsrCzNnTtXI0eOlNRy/X3BggV6/PHHu+TP7EodHasJEybI5XJp6dKlOu200yRJS5Yskcvl0sSJEw/7Mc3NzWpublZExIETr5GRke0zU8GkK8cqJiZGY8eO1caNGw94ftOmTR0+tDyQdOVYzZgx45B/WKZOnaoZM2bo+uuvP/HwftSV4yTtK3SbN2/WvHnzQq60xMTEaPTo0Zo7d64uv/zy9ufnzp2r6dOnH/ZjJkyYoE8++eSA5+bMmaMxY8YoOjq6S/OadDxjJbXM0P34xz/WW2+91f7Deajr7FglJSVp3bp1Bzw3a9Ysff755/rb3/6mPn36dHnmgOevFRnbt2+3Vq1aZT344INWYmKitWrVKmvVqlVWTU1N+2sGDhxozZ49u/39xx57zHI6ndbs2bOtdevWWT/4wQ/CZkuT4cOHW4sWLbIWLVpkDRs27JAtFQ4eq0mTJllDhw615s2bZ23bts169dVXrdjYWGvWrFn+ju9XxzNWs2fPtqKjo60XX3zR2rx5s/XHP/7RioyMtL788kt/x/er4xmrg4X66lfL6vw4NTc3W5deeqmVm5trrV692iotLW1/uN1uE59Cl2jbeuKVV16x8vPzrV/+8pdWQkKCVVhYaFmWZc2cOdO68sorD9nS5I477rDy8/OtV155Jey2NDnaWM2YMaP99W+++aYVFRVlPffccwd8/VRVVZn6FPyms2N1MFa/Hshvpe66666zJB3ymDdv3r4wkvXqq6+2v+/z+az777/fysrKsux2u3XWWWdZ69at81dkY8rLy62rr77acjgclsPhsK6++mqrsrLygNccPFalpaXWj370Iys7O9uKjY21Bg4caD355JOWz+fzb3g/O56xsizLeuWVV6z+/ftbsbGx1ogRI0J+Pz/LOv6x2l84lLrOjlNBQcFhv7cd/P0tFDz33HNWr169rJiYGGvUqFHWggUL2n/vuuuus8466yzL5XK1f9+ZP3++NXLkSCsmJsbq3bu39fzzz5uK7nfHGqtJkya1vz9p0qTDfv1cd911/g9uQGfG6mCUugPZLKv1zlUAAAAErYDd0gQAAAAdR6kDAAAIAZQ6AACAEECpAwAACAGUOgAAgBBAqQMAAAgBlDoAAIAQQKkDAAAIAZQ6AACAEECpAwAACAGUOgAAgBBAqQMQkt566y3FxsZq586d7c/dcMMNGj58uFwul8FkANA1bJZlWaZDAMDJZlmWTj31VJ155pl69tln9eCDD+rll1/W4sWLlZOTYzoeAJx0UaYDAEBXsNlsevjhh/W9731P2dnZevrpp/Xll19S6ACELGbqAIS0UaNGaf369ZozZ44mTZpkOg4AdBnuqQMQsj777DNt2LBBXq9XmZmZpuMAQJdipg5ASFq5cqXOPvtsPffcc3r77bcVHx+v9957z3QsAOgy3FMHIOQUFhZq2rRpmjlzpmbMmKEhQ4Zo7NixWrFihUaPHm06HgB0CWbqAISUiooKnX766TrrrLP0wgsvtD8/ffp0ud1uffrppwbTAUDXodQBAACEABZKAAAAhABKHQAAQAig1AEAAIQASh0AAEAIoNQBAACEAEodAABACKDUAQAAhABKHQAAQAig1AEAAIQASh0AAEAIoNQBAACEgP8PXr/oic6DUH8AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x787b316fac10>"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr.subs(a,-2),(x,-0.98,0.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 x \\log{\\left(x + 1 \\right)} + x + 2 \\log{\\left(x + 1 \\right)}}{x + 1}$"
      ],
      "text/plain": [
       "(2*x*log(x + 1) + x + 2*log(x + 1))/(x + 1)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr.subs(a,-2),x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=fraction(_)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 x \\log{\\left(x + 1 \\right)} + x + 2 \\log{\\left(x + 1 \\right)}$"
      ],
      "text/plain": [
       "2*x*log(x + 1) + x + 2*log(x + 1)"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x787b320406d0>"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(check,(x,-0.9,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\log{\\left(x + 1 \\right)} + 3$"
      ],
      "text/plain": [
       "2*log(x + 1) + 3"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(check,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - a \\log{\\left(x + 1 \\right)} - 1 + \\frac{- a x + 1}{x + 1}$"
      ],
      "text/plain": [
       "-a*log(x + 1) - 1 + (-a*x + 1)/(x + 1)"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(expr,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\frac{x}{x \\log{\\left(x + 1 \\right)} + x + \\log{\\left(x + 1 \\right)}}\\right\\}$"
      ],
      "text/plain": [
       "{-x/(x*log(x + 1) + x + log(x + 1))}"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "\nUnable to find range for the given domain.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[138], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m function_range(\u001b[38;5;28mlist\u001b[39m(_)[\u001b[38;5;241m0\u001b[39m],x,Interval(\u001b[38;5;241m0\u001b[39m,oo))\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/sympy/calculus/util.py:173\u001b[0m, in \u001b[0;36mfunction_range\u001b[0;34m(f, symbol, domain)\u001b[0m\n\u001b[1;32m    170\u001b[0m     interval_iter \u001b[38;5;241m=\u001b[39m intervals\u001b[38;5;241m.\u001b[39margs\n\u001b[1;32m    172\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 173\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m(filldedent(\u001b[38;5;124m'''\u001b[39m\n\u001b[1;32m    174\u001b[0m \u001b[38;5;124m            Unable to find range for the given domain.\u001b[39m\n\u001b[1;32m    175\u001b[0m \u001b[38;5;124m            \u001b[39m\u001b[38;5;124m'''\u001b[39m))\n\u001b[1;32m    177\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m interval \u001b[38;5;129;01min\u001b[39;00m interval_iter:\n\u001b[1;32m    178\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(interval, FiniteSet):\n",
      "\u001b[0;31mNotImplementedError\u001b[0m: \nUnable to find range for the given domain."
     ]
    }
   ],
   "source": [
    "function_range(list(_)[0],x,Interval(0,oo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr1=diff(expr,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr1.subs(x,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{a x + 2 a + 1}{\\left(x + 1\\right)^{2}}$"
      ],
      "text/plain": [
       "-(a*x + 2*a + 1)/(x + 1)**2"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr1,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "d=symbols(\"d\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "an=sequence(a+d*(n-1),(n,1,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[a, a + d, a + 2 d, a + 3 d, \\ldots\\right]$"
      ],
      "text/plain": [
       "SeqFormula(a + d*(n - 1), (n, 1, 10))"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "an"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 10$"
      ],
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "an.length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( -4, \\  3\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(-4, 3)}"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linsolve([an[2]+an[3]-7,3*an[1]+an[4]-5],[a,d])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 95$"
      ],
      "text/plain": [
       "95"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(an).subs({a:-4,d:3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=Function(\"f\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [],
   "source": [
    "eq=Eq(4*f(n),3*(f(n)-f(n-1))+4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 f{\\left(n \\right)} = 3 f{\\left(n \\right)} - 3 f{\\left(n - 1 \\right)} + 4$"
      ],
      "text/plain": [
       "Eq(4*f(n), 3*f(n) - 3*f(n - 1) + 4)"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1 - \\left(-3\\right)^{n}$"
      ],
      "text/plain": [
       "1 - (-3)**n"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rsolve(eq,f(n),{f(1):4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "an=expr-expr.subs(n,n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\left(-3\\right)^{n} + \\left(-3\\right)^{n - 1}$"
      ],
      "text/plain": [
       "-(-3)**n + (-3)**(n - 1)"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "an"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 \\left(-3\\right)^{n - 1}$"
      ],
      "text/plain": [
       "4*(-3)**(n - 1)"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{4 \\left(-1\\right)^{n} \\left(-3\\right)^{n} n}{3}$"
      ],
      "text/plain": [
       "4*(-1)**n*(-3)**n*n/3"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify((-1)**(n-1)*n*an)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "bn=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\left(-1\\right)^{n} \\left(-3\\right)^{n} n - \\left(-1\\right)^{n} \\left(-3\\right)^{n} + 1$"
      ],
      "text/plain": [
       "2*(-1)**n*(-3)**n*n - (-1)**n*(-3)**n + 1"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation(bn,(n,1,n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\left(-1\\right)^{n} \\left(-3\\right)^{n} n - \\left(-1\\right)^{n} \\left(-3\\right)^{n} + 1$"
      ],
      "text/plain": [
       "2*(-1)**n*(-3)**n*n - (-1)**n*(-3)**n + 1"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(x,\"__sympy__\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Hi(Basic):\n",
    "    def __init__(self,name) -> None:\n",
    "        self.name=name\n",
    "    \n",
    "    def _latex(self,printer):\n",
    "        return self.name\n",
    "    \n",
    "    def _sympystr(self,printer):\n",
    "        return self.name\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=Hi(\"huang\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle huang$"
      ],
      "text/plain": [
       "huang"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x110de6f10>]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABLn0lEQVR4nO3deXxU9b3/8ddkmwRIBgJkIyGyBDACIVFWEUFlsyIIApJekNZrbQ2buFOpUHuJuJattP3VC/ZWAiIEUISClUUEUcjCvgomLGFPJglknfP7w5oaIYEJCWcmeT8fj3k8mDPf78nny+Rk3vl+T86xGIZhICIiIuLCPMwuQEREROR6FFhERETE5SmwiIiIiMtTYBERERGXp8AiIiIiLk+BRURERFyeAouIiIi4PAUWERERcXleZhdQXRwOB6dOncLf3x+LxWJ2OSIiInIDDMMgNzeXsLAwPDwqnkepNYHl1KlTREREmF2GiIiIVEFmZibh4eEVvl5rAou/vz/w/YADAgJMrkZERERuhN1uJyIiouxzvCK1JrD8sAwUEBCgwCIiIuJmrnc6h066FREREZenwCIiIiIuT4FFREREXJ4Ci4iIiLg8BRYRERFxeQosIiIi4vIUWERERMTlKbCIiIiIy1NgEREREZfnVGCZP38+HTt2LLuabPfu3VmzZk3Z64ZhMG3aNMLCwvDz86N3797s3bv3uvtdtmwZ0dHRWK1WoqOjSU5Odn4kIiIiUms5FVjCw8N5/fXX2bFjBzt27OC+++5j8ODBZaHkjTfe4J133mHu3Ll88803hISE0LdvX3Jzcyvc57Zt2xg5ciSjR48mPT2d0aNHM2LECLZv335zIxMREZFaw2IYhnEzOwgMDOTNN9/kl7/8JWFhYUyaNIkXX3wRgMLCQoKDg5k5cyZPPfXUNfuPHDkSu91ebqZmwIABNGrUiKSkpBuuw263Y7PZyMnJ0b2ERERE3MSNfn5X+RyW0tJSFi9eTH5+Pt27d+fYsWNkZWXRr1+/sjZWq5V7772XrVu3Vrifbdu2lesD0L9//0r7wPdhyG63l3uIiIhI9Vu75zS//r+dlDpuao7jpjgdWHbv3k2DBg2wWq38+te/Jjk5mejoaLKysgAIDg4u1z44OLjstWvJyspyug9AYmIiNput7BEREeHsUERERKQSBcWlvLpyD7/+Rwpr92axdEemabU4HVjatm1LWloaX331Fb/5zW94/PHH2bdvX9nrP709tGEY171ldFX6vPzyy+Tk5JQ9MjPN+08UERGpbY6fz2fY/K28v+07AJ66tyXD7gw3rR4vZzv4+PjQunVrAO666y6++eYbZs2aVXbeSlZWFqGhoWXtz549e9UMyo+FhIRcNZtyvT7w/XKT1Wp1tnwRERG5jo/TT/Hy8t3kFZYQWN+Ht0fE0KdtkKk13fR1WAzDoLCwkBYtWhASEsL69evLXisqKmLTpk306NGjwv7du3cv1wdg3bp1lfYRERGR6ldQXMrLy3czPimVvMISutwWyKcT7jE9rICTMyxTpkxh4MCBREREkJuby+LFi9m4cSNr167FYrEwadIkZsyYQVRUFFFRUcyYMYN69eoRHx9fto8xY8bQrFkzEhMTAZg4cSK9evVi5syZDB48mJUrV/LZZ5+xZcuW6h2piIiIVOjouTwSPkjhQFYuFguM69OaifdH4eXpGteYdSqwnDlzhtGjR3P69GlsNhsdO3Zk7dq19O3bF4AXXniBK1eu8PTTT3Pp0iW6du3KunXr8Pf3L9tHRkYGHh7/GXyPHj1YvHgxr7zyClOnTqVVq1YsWbKErl27VtMQRUREpDLJqSf4bfIeLheV0qSBD++O7MQ9UU3NLqucm74Oi6vQdVhEREScc6WolN+t3MPSnScA6N6yMbMe60RQgO8tq+FGP7+dPulWRERE3N+hM7kkfJDC4bN5WCww8f4oxt8XhadH5X+laxYFFhERkTrEMAyW7jzB71buoaDYQVN/K7Me60SPVk3MLq1SCiwiIiJ1RH5hCVNX7GF56kkA7olqwrsjO9GkgetfJkSBRUREpA7Yf9pOwqIUvj2Xj4cFnu3Xlt/c2woPF10C+ikFFhERkVrMMAySvs5k+sd7KSxxEBLgy+xRsXRpEWh2aU5RYBEREamlcguKmZK8h4/TTwHQp21T3h7RicD6PiZX5jwFFhERkVpoz8kcxi1K4fiFy3h5WHi+f1uevKel2ywB/ZQCi4iISC1iGAb/99V3/OGT/RSVOmjW0I/Zo2K5M7KR2aXdFAUWERGRWiLnSjEvLdvFmj3f31T4gduDeWt4RxrWc78loJ9SYBEREakF0jOzGZeUQubFK3h7Wnhp4O388u7bsFjccwnopxRYRERE3JhhGPzvl8d5fc1+iksNIgL9mDsqjpiIhmaXVq0UWERERNxU9uUinlu6i8/2nwFgYPsQXh/WEZuft8mVVT8FFhERETe087tLTEhK5WT2FXw8PXjlodsZ3S2y1iwB/ZQCi4iIiBtxOAz+3xff8uY/D1LiMIhsXI958XG0b2Yzu7QapcAiIiLiJi7mF/Hsh2lsOHgOgIc6hpI4tAP+vrVvCeinFFhERETcwNfHLjIhKZUsewFWLw9eHXQHo7pE1NoloJ9SYBEREXFhDofB/E1HeWf9IUodBi2b1mdefBy3hwaYXdotpcAiIiLios7nFfLMkjS+OHwegKGxzXhtSHvqW+vex3fdG7GIiIgb2Hr0PBMXp3EutxBfbw9+P7g9w+8MrzNLQD+lwCIiIuJCSh0Gcz4/zOx/HcZhQFRQA+b9PI42wf5ml2YqBRYREREXcdZewKQlaWw9egGAEXeFM/3h9vj5eJpcmfkUWERERFzAF4fP8cySNM7nFVHPx5M/DGnP0Lhws8tyGQosIiIiJiopdfDHzw4zb+MRDAPahfgzNz6O1kENzC7NpSiwiIiImCQrp4AJSal8ffwiAPFdm/O7h6Lx9dYS0E8psIiIiJhgw8GzPPthOhfzi2hg9WLG0A48HBNmdlkuS4FFRETkFioudfDWuoP8ZdO3ANwRFsDc+DhaNKlvcmWuTYFFRETkFjmZfYUJSans/O4SAI93j+TlB2/XEtANUGARERG5BdbvO8NzS9PJuVKMv68XbwzryMAOoWaX5TYUWERERGpQUYmDmWsP8N6WYwDEhNuYMyqO5o3rmVyZe1FgERERqSGZFy8zLimV9MxsAH55dwteGtgOHy8PcwtzQwosIiIiNWDtntM8/9EucgtKsPl589bwGPpGB5tdlttyKuIlJibSuXNn/P39CQoKYsiQIRw8eLBcG4vFcs3Hm2++WeF+Fy5ceM0+BQUFVRuViIiISQpLSnl15R5+/Y8UcgtKiG3ekNUTeiqs3CSnZlg2bdpEQkICnTt3pqSkhN/+9rf069ePffv2Ub/+93+Odfr06XJ91qxZwxNPPMGwYcMq3XdAQMBV4cfX19eZ8kREREx1/Hw+45JS2HPSDsBT97bkuX5t8fbUEtDNciqwrF27ttzzBQsWEBQUxM6dO+nVqxcAISEh5dqsXLmSPn360LJly0r3bbFYruorIiLiLj7ZdYqXlu0mr7CERvW8eWdEJ/q0CzK7rFrjps5hycnJASAwMPCar585c4bVq1fz/vvvX3dfeXl5REZGUlpaSqdOnXjttdeIjY2tsH1hYSGFhYVlz+12u5PVi4iI3LyC4lJ+/8k+Fm3PAKDzbY2YPSqWUJufyZXVLlWeozIMg8mTJ9OzZ0/at29/zTbvv/8+/v7+DB06tNJ9tWvXjoULF7Jq1SqSkpLw9fXl7rvv5vDhwxX2SUxMxGazlT0iIiKqOhQREZEqOXoujyHzvmTR9gwsFkjo04qkJ7sprNQAi2EYRlU6JiQksHr1arZs2UJ4+LVvf92uXTv69u3LnDlznNq3w+EgLi6OXr16MXv27Gu2udYMS0REBDk5OQQEBDj19URERJy1IvUkU5J3c7molMb1fXh3ZCd6tWlqdllux263Y7PZrvv5XaUlofHjx7Nq1So2b95cYVj54osvOHjwIEuWLHF6/x4eHnTu3LnSGRar1YrVanV63yIiIjfjSlEp01btZcmOTAC6t2zMrMc6ERSgPxSpSU4FFsMwGD9+PMnJyWzcuJEWLVpU2Pa9997jzjvvJCYmxumiDMMgLS2NDh06ON1XRESkphw+k0vCohQOncnDYoEJ90Ux4f4oPD0sZpdW6zkVWBISEli0aBErV67E39+frKwsAGw2G35+/1mvs9vtLF26lLfffvua+xkzZgzNmjUjMTERgOnTp9OtWzeioqKw2+3Mnj2btLQ05s2bV9VxiYiIVKulOzKZunIPBcUOmvpbmTWyEz1aNzG7rDrDqcAyf/58AHr37l1u+4IFCxg7dmzZ88WLF2MYBqNGjbrmfjIyMvDw+M/5vtnZ2fzqV78iKysLm81GbGwsmzdvpkuXLs6UJyIiUu3yC0uYunIPy1NOAnBPVBPeGdGJpv46LeFWqvJJt67mRk/aERERuVEHsuwkfJDC0XP5eFhgct82PN27NR5aAqo2NXrSrYiISG1mGAaLv8lk2qq9FJY4CA6wMvuxWLq2bGx2aXWWAouIiMiP5BYUMyV5Dx+nnwKgd9umvD08hsYNtARkJgUWERGRf9tzModxi1I4fuEynh4Wnu/fll/d01JLQC5AgUVEROo8wzD4x1ff8don+ykqdRBm82VOfCx3Rl771jNy6ymwiIhInWYvKOalZbv4dPf3l+p44PYg3hoeQ8N6PiZXJj+mwCIiInXWrhPZJCxKIfPiFbw9Lbw4oB1P9GyBxaIlIFejwCIiInWOYRgs+PI4iWv2U1xqEN7Ij7nxcXSKaGh2aVIBBRYREalTsi8X8fxHu1i/7wwAA+4IYeajHbH5eZtcmVRGgUVEROqMlIxLjF+UysnsK/h4evDbn93OmO6RWgJyAwosIiJS6zkcBn/b8i1vrD1IicMgsnE95sXH0b6ZzezS5AYpsIiISK12Mb+I55am8/mBswA81DGUxKEd8PfVEpA7UWAREZFa65vjF5mQlMrpnAJ8vDx4dVA08V2aawnIDSmwiIhIreNwGMzfdJR31h+i1GHQskl95sbHER2mm+O6KwUWERGpVc7nFfLMkjS+OHwegEdim/GHIe2pb9VHnjvTuyciIrXGtqMXmLg4lbO5hfh6e/D7h9sz/K5wLQHVAgosIiLi9kodBnM/P8Ksfx3CYUDroAb86edxtAn2N7s0qSYKLCIi4tbO5hYwaXEaW49eAGD4neFMH3wH9Xz0EVeb6N0UERG3teXweSYtSeV8XhH1fDz5w5D2DI0LN7ssqQEKLCIi4nZKSh3M+tdh5m44gmFAuxB/5sbH0TqogdmlSQ1RYBEREbeSlVPAhMWpfH3sIgCjujTn1UHR+Hp7mlyZ1CQFFhERcRsbD55l8ofpXMwvor6PJ4nDOvJwTJjZZcktoMAiIiIur7jUwdvrDvHnTUcBiA4NYN7P42jRpL7JlcmtosAiIiIu7VT2FcYnpbLzu0sAjOkeyZQHb9cSUB2jwCIiIi7rs31neO6jdLIvF+Nv9WLmox15sEOo2WWJCRRYRETE5RSVOHhj7QH+tuUYAB3DbcwdFUfzxvVMrkzMosAiIiIuJfPiZcYlpZKemQ3AL+9uwYsD22L10hJQXabAIiIiLmPtnixe+Cgde0EJAb5evDU8hn53hJhdlrgABRYRETFdYUkpiZ8eYOHW4wDENm/InFGxhDfSEpB8T4FFRERM9d2FfMYtSmX3yRwAnurVkuf6t8Xb08PkysSVKLCIiIhpPtl1ipeW7SavsIRG9bx5e0QM97ULNrsscUEKLCIicssVFJfy2if7+GB7BgCdb2vE7FGxhNr8TK5MXJVT822JiYl07twZf39/goKCGDJkCAcPHizXZuzYsVgslnKPbt26XXffy5YtIzo6GqvVSnR0NMnJyc6NRERE3MK35/J45E9by8LK071bkfRkN4UVqZRTgWXTpk0kJCTw1VdfsX79ekpKSujXrx/5+fnl2g0YMIDTp0+XPT799NNK97tt2zZGjhzJ6NGjSU9PZ/To0YwYMYLt27c7PyIREXFZK1JP8tCcLew/badxfR/e/2UXXhjQDi+dryLXYTEMw6hq53PnzhEUFMSmTZvo1asX8P0MS3Z2NitWrLjh/YwcORK73c6aNWvKtg0YMIBGjRqRlJR0Q/uw2+3YbDZycnIICAhwahwiIlKzrhSVMm3VXpbsyASgW8tAZj0WS3CAr8mVidlu9PP7piJtTs73Z3QHBgaW275x40aCgoJo06YNTz75JGfPnq10P9u2baNfv37ltvXv35+tW7dW2KewsBC73V7uISIirufI2VyGzPuSJTsysVhgwv1RfPDf3RRWxClVPunWMAwmT55Mz549ad++fdn2gQMHMnz4cCIjIzl27BhTp07lvvvuY+fOnVit1mvuKysri+Dg8meFBwcHk5WVVeHXT0xMZPr06VUtX0REboGPdp5g6oo9XCkupUkDK7Mf60SP1k3MLkvcUJUDy7hx49i1axdbtmwpt33kyJFl/27fvj133XUXkZGRrF69mqFDh1a4P4vFUu65YRhXbfuxl19+mcmTJ5c9t9vtREREODsMERGpAZeLSnhlxR6Wp5wEoGfrJrw7shNN/a/9i6vI9VQpsIwfP55Vq1axefNmwsPDK20bGhpKZGQkhw8frrBNSEjIVbMpZ8+evWrW5cesVmuFMzYiImKeA1l2Ej5I4ei5fDwsMLlvG37TuzWeHhX/EipyPU6dw2IYBuPGjWP58uV8/vnntGjR4rp9Lly4QGZmJqGhFd8OvHv37qxfv77ctnXr1tGjRw9nyhMRERMZhsHirzMYPPdLjp7LJzjAStKT3Rh3X5TCitw0p2ZYEhISWLRoEStXrsTf379sVsRms+Hn50deXh7Tpk1j2LBhhIaGcvz4caZMmUKTJk145JFHyvYzZswYmjVrRmJiIgATJ06kV69ezJw5k8GDB7Ny5Uo+++yzq5abRETENeUVljBl+W5WpZ8C4N42TXlnRAyNG2gmXKqHU4Fl/vz5APTu3bvc9gULFjB27Fg8PT3ZvXs3f//738nOziY0NJQ+ffqwZMkS/P39y9pnZGTg4fGfyZ0ePXqwePFiXnnlFaZOnUqrVq1YsmQJXbt2vYmhiYjIrbD3VA7jFqVy7Hw+nh4WnuvXlqd6tcRDsypSjW7qOiyuRNdhERG5tQzD4B/bM3jtk30UlTgIs/kyJz6WOyMDr99Z5N9u9PNb9xISERGn2QuKeXnZblbvPg3AA7cH8eajMTSq72NyZVJbKbCIiIhTdp3IZtyiVDIuXsbLw8JLA9vxRM8WlV6KQuRmKbCIiMgNMQyDhVuPM+PT/RSXGjRr6Mfc+FhimzcyuzSpAxRYRETkunIuF/P8R+ms23cGgP53BPPGsBhs9bxNrkzqCgUWERGpVGrGJcYtSuVk9hV8PD2Y8mA7Hu9xm5aA5JZSYBERkWtyOAze23KMmWsPUOIwaB5Yj3nxcXQIt5ldmtRBCiwiInKVS/lFPLs0nc8PnAXgZx1DSRzagQBfLQGJORRYRESknB3HLzI+KZXTOQX4eHnwu4ei+XnX5loCElMpsIiICPD9EtCfNx/l7XWHKHUYtGxSn7nxcUSH6WKcYj4FFhER4XxeIZM/TGfzoXMADOkUxh8e6UADqz4mxDXoO1FEpI776tsLTEhK5WxuIb7eHkx/+A5G3BWhJSBxKQosIiJ1VKnDYN6GI/zxs0M4DGgd1IB58XG0DfG/fmeRW0yBRUSkDjqbW8AzS9L48sgFAB69M5zfD76Dej76WBDXpO9MEZE65ssj55m4OI3zeYX4eXvyhyHtGXZnuNlliVRKgUVEpI4odRjM+uwQczYcwTCgbbA/834eS+sgLQGJ61NgERGpA87YC5iQlMr2YxcBGNUlglcH3YGvt6fJlYncGAUWEZFabuPBs0z+MJ2L+UXU9/FkxtAODO7UzOyyRJyiwCIiUkuVlDp4e/0h5m88CkB0aABz42Np2bSByZWJOE+BRUSkFjqVfYUJSans+O4SAKO7RfLbn92uJSBxWwosIiK1zL/2n+HZpelkXy7G3+rF68M68rOOoWaXJXJTFFhERGqJohIHb/7zAP/vi2MAdGhmY258LJGN65tcmcjNU2AREakFMi9eZnxSKmmZ2QD84u7beGlgO6xeWgKS2kGBRUTEzf1zbxbPL03HXlBCgK8Xbw6Pof8dIWaXJVKtFFhERNxUYUkpiZ8eYOHW4wB0imjInFGxRATWM7cwkRqgwCIi4oa+u5DPuEWp7D6ZA8CT97Tg+f7t8PHyMLkykZqhwCIi4mZW7zrNS8t2kVtYQsN63rw9PIb7bw82uyyRGqXAIiLiJgqKS/nD6n3846sMAO6KbMTsUbGENfQzuTKRmqfAIiLiBr49l0fColT2n7YD8HTvVjzTtw3enloCkrpBgUVExMWtTDvJlOW7yS8qpXF9H94Z2Yl72zQ1uyyRW0qBRUTERV0pKmX6x3tZ/E0mAF1bBDJ7VCzBAb4mVyZy6ymwiIi4oCNnc0n4IJWDZ3KxWGD8fVFMuK81XloCkjrKqe/8xMREOnfujL+/P0FBQQwZMoSDBw+WvV5cXMyLL75Ihw4dqF+/PmFhYYwZM4ZTp05Vut+FCxdisViuehQUFFRtVCIibuyjnScYNOdLDp7JpUkDK/94oiuT+7ZRWJE6zanv/k2bNpGQkMBXX33F+vXrKSkpoV+/fuTn5wNw+fJlUlJSmDp1KikpKSxfvpxDhw7x8MMPX3ffAQEBnD59utzD11fTniJSd1wuKuHZD9N5bmk6V4pLubt1Yz6d2JO7WzcxuzQR0zm1JLR27dpyzxcsWEBQUBA7d+6kV69e2Gw21q9fX67NnDlz6NKlCxkZGTRv3rzCfVssFkJCdClpEambDmblkrAohSNn8/CwwKQH2pDQpzWeHhazSxNxCTd1DktOzvdXWAwMDKy0jcVioWHDhpXuKy8vj8jISEpLS+nUqROvvfYasbGxFbYvLCyksLCw7LndbneueBERF2AYBh/uyOR3K/dSWOIgOMDKrMdi6daysdmlibiUKi+IGobB5MmT6dmzJ+3bt79mm4KCAl566SXi4+MJCAiocF/t2rVj4cKFrFq1iqSkJHx9fbn77rs5fPhwhX0SExOx2Wxlj4iIiKoORUTEFHmFJTyzJI0Xl+2msMRBrzZN+XTCPQorItdgMQzDqErHhIQEVq9ezZYtWwgPD7/q9eLiYoYPH05GRgYbN26sNLD8lMPhIC4ujl69ejF79uxrtrnWDEtERAQ5OTlOfS0RETPsPZXD+EWpfHs+H08PC8/2a8Ove7XCQ0tAUsfY7XZsNtt1P7+rtCQ0fvx4Vq1axebNmysMKyNGjODYsWN8/vnnTgcIDw8POnfuXOkMi9VqxWq1Ol27iIiZDMPgH9szeO2TfRSVOAi1+TJnVCx33Vbx0rqIOBlYDMNg/PjxJCcns3HjRlq0aHFVmx/CyuHDh9mwYQONGzs/tWkYBmlpaXTo0MHpviIirspeUMzLy3ezetdpAO5vF8Rbw2NoVN/H5MpEXJ9TgSUhIYFFixaxcuVK/P39ycrKAsBms+Hn50dJSQmPPvooKSkpfPLJJ5SWlpa1CQwMxMfn+4NyzJgxNGvWjMTERACmT59Ot27diIqKwm63M3v2bNLS0pg3b151jlVExDS7T+SQsCiFjIuX8fKw8NLAdjzRswUWi5aARG6EU4Fl/vz5APTu3bvc9gULFjB27FhOnDjBqlWrAOjUqVO5Nhs2bCjrl5GRgYfHf873zc7O5le/+hVZWVnYbDZiY2PZvHkzXbp0cXI4IiKuxTAM3t96nBmfHqCo1EGzhn7MjY8ltnkjs0sTcStVPunW1dzoSTsiIrdKzuViXliWzj/3ngGgX3Qwbz4ag62et8mVibiOGj3pVkREKpeacYnxSamcuHQFb08LUx68nbE9btMSkEgVKbCIiFQjwzB4b8sxXl9zgBKHQfPAesyNj6VjeEOzSxNxawosIiLV5FJ+Ec8tTedfB84C8LMOoSQO60CAr5aARG6WAouISDXY+d1Fxi9K5VROAT5eHkx9KJr/6tpcS0Ai1USBRUTkJjgcBn/Z/C1vrTtIqcOgRZP6zI2P5Y4wm9mlidQqCiwiIlV0Ia+QyR+ms+nQOQAGdwrjfx7pQAOrfrSKVDcdVSIiVbD92wtMWJzKGXshVi8Ppj98ByM7R2gJSKSGKLCIiDih1GHwpw1HePezQzgMaNW0PvN+Hke7EF3/SaQmKbCIiNygc7mFTFqSypdHLgAwLC6c14bcQT0f/SgVqWk6ykREbsCXR84zcXEa5/MK8fP25LUh7Xn0zqvvVi8iNUOBRUSkEqUOg1n/Osyczw9jGNA22J+58bFEBfubXZpInaLAIiJSgTP2AiYuTuWrby8C8FjnCF4ddAd+Pp4mVyZS9yiwiIhcw6ZD55i8JI0L+UXU9/FkxtAODO7UzOyyROosBRYRkR8pKXXwzvpD/GnjUQBuDw1gXnwsLZs2MLkykbpNgUVE5N9O51xhQlIq3xy/BMB/dWvOKz+LxtdbS0AiZlNgEREBPj9whmc/TOfS5WIaWL14fVgHHuoYZnZZIvJvCiwiUqcVlzp4858H+evmbwHo0MzG3PhYIhvXN7kyEfkxBRYRqbNOXLrMuEWppGVmAzC2x228/GA7rF5aAhJxNQosIlIn/XNvFs8vTcdeUEKArxdvPBrDgPYhZpclIhVQYBGROqWoxEHimv0s+PI4ADERDZk7KpaIwHrmFiYilVJgEZE6I+PCZcYlpbDrRA4AT97Tguf7t8PHy8PkykTkehRYRKRO+HT3aV78aBe5hSU0rOfNW4/G8EB0sNllicgNUmARkVqtoLiU/1m9n//76jsA7oxsxJxRsYQ19DO5MhFxhgKLiNRax87nk/BBCvtO2wH4Te9WTO7bBm9PLQGJuBsFFhGplVamnWTK8t3kF5USWN+Hd0bE0LttkNlliUgVKbCISK1SUFzK9I/3kvR1JgBdWgQy+7FYQmy+JlcmIjdDgUVEao0jZ/NI+CCFg2dysVhgfJ/WTLg/Ci8tAYm4PQUWEakVlu08wSsr9nCluJQmDaz8cWQnekY1MbssEakmCiwi4tYuF5Xwu5V7+WjnCQB6tGrMHx/rRJC/loBEahMFFhFxW4fO5JLwQQqHz+bhYYFJD7QhoU9rPD0sZpcmItVMgUVE3I5hGHy4I5NXV+2loNhBkL+VWY/F0r1VY7NLE5Ea4tSZaImJiXTu3Bl/f3+CgoIYMmQIBw8eLNfGMAymTZtGWFgYfn5+9O7dm717915338uWLSM6Ohqr1Up0dDTJycnOjURE6oS8whKeWZLGi8t2U1Ds4J6oJnw68R6FFZFazqnAsmnTJhISEvjqq69Yv349JSUl9OvXj/z8/LI2b7zxBu+88w5z587lm2++ISQkhL59+5Kbm1vhfrdt28bIkSMZPXo06enpjB49mhEjRrB9+/aqj0xEap19p+w8PGcLK9JO4elh4YUBbXn/F11o0sBqdmkiUsMshmEYVe187tw5goKC2LRpE7169cIwDMLCwpg0aRIvvvgiAIWFhQQHBzNz5kyeeuqpa+5n5MiR2O121qxZU7ZtwIABNGrUiKSkpBuqxW63Y7PZyMnJISAgoKpDEhEXZBgGi77OYPrH+ygqcRBq82X2qFg63xZodmkicpNu9PP7pi5OkJPz/R1PAwO//6Fx7NgxsrKy6NevX1kbq9XKvffey9atWyvcz7Zt28r1Aejfv3+lfQoLC7Hb7eUeIlL75BYUMy4pld8m76GoxMF97YJYPeEehRWROqbKgcUwDCZPnkzPnj1p3749AFlZWQAEB5e/A2pwcHDZa9eSlZXldJ/ExERsNlvZIyIioqpDEREXtedkDg/N2cLqXafx8rDw2wdv529j7iKwvo/ZpYnILVblvxIaN24cu3btYsuWLVe9ZrGU/5NCwzCu2nazfV5++WUmT55c9txutyu0iNQShmHw/tbjzPj0AEWlDpo19GNOfCxxzRuZXZqImKRKgWX8+PGsWrWKzZs3Ex4eXrY9JCQE+H7GJDQ0tGz72bNnr5pB+bGQkJCrZlOu18dqtWK16kQ7kdom50oxL360i7V7v/+Z0C86mDcfjcFWz9vkykTETE4tCRmGwbhx41i+fDmff/45LVq0KPd6ixYtCAkJYf369WXbioqK2LRpEz169Khwv927dy/XB2DdunWV9hGR2ictM5ufzf6CtXuz8Pa08OqgaP4y+k6FFRFxboYlISGBRYsWsXLlSvz9/ctmRWw2G35+flgsFiZNmsSMGTOIiooiKiqKGTNmUK9ePeLj48v2M2bMGJo1a0ZiYiIAEydOpFevXsycOZPBgwezcuVKPvvss2suN4lI7WMYBu9tOcbraw5Q4jBoHliPufGxdAxvaHZpIuIinAos8+fPB6B3797lti9YsICxY8cC8MILL3DlyhWefvppLl26RNeuXVm3bh3+/v5l7TMyMvDw+M/kTo8ePVi8eDGvvPIKU6dOpVWrVixZsoSuXbtWcVgi4i6yLxfx3NJ0Ptt/FoAHO4Tw+rCOBPhqVkVE/uOmrsPiSnQdFhH3s/O7i4xflMqpnAJ8vDyY+lA0/9W1+XVP0heR2uNGP791LyERueUcDoO/fvEtb/7zIKUOgxZN6jM3PpY7wmxmlyYiLkqBRURuqQt5hTy7NJ2NB88B8HBMGDOGdqCBVT+ORKRi+gkhIrfM9m8vMGFxKmfshVi9PJj28B081jlCS0Aicl0KLCJS40odBn/acIR3PzuEw4BWTesz7+dxtAvR+WYicmMUWESkRp3LLeSZJWlsOXIegKFxzXhtcHvqawlIRJygnxgiUmO2HjnPxCVpnMstxM/bk98PvoPhd+kWGiLiPAUWEal2pQ6DWf86zJzPD2MY0Ca4AfPi44gK9r9+ZxGRa1BgEZFqdcZewMTFqXz17UUARt4VwbSH78DPx9PkykTEnSmwiEi12XzoHM8sSeNCfhH1fDyZ8UgHhsQ2M7ssEakFFFhE5KaVlDp497ND/GnjUQwDbg8NYF58LC2bNjC7NBGpJRRYROSmnM65woSkVL45fgmAn3dtztSHovH11hKQiFQfBRYRqbINB84y+cM0Ll0upoHVi9eHdeChjmFmlyUitZACi4g4rbjUwVv/PMhfNn8LQPtmAcwdFcdtTeqbXJmI1FYKLCLilBOXLjM+KZXUjGwAxva4jZcfbIfVS0tAIlJzFFhE5Iat25vF8x/tIudKMf6+Xrz5aEcGtA81uywRqQMUWETkuopKHCSu2c+CL48DEBPRkLmjYokIrGduYSJSZyiwiEilMi5cZlxSCrtO5ADw3z1b8MKAdvh4eZhcmYjUJQosIlKhNbtP88JHu8gtLMHm583bw2N4IDrY7LJEpA5SYBGRqxQUlzLj0/38fdt3ANwZ2YjZo2Jp1tDP5MpEpK5SYBGRco6dz2fcohT2nrID8Ot7W/FsvzZ4e2oJSETMo8AiImVWpZ9iyvLd5BWWEFjfh7dHxNCnbZDZZYmIKLCIyPdLQNM/3kfS1xkAdLktkNmjYgmx+ZpcmYjI9xRYROq4I2fzGLcohQNZuVgsMK5PaybeH4WXloBExIUosIjUYctTTvDKij1cLiqlSQMf/jgylp5RTcwuS0TkKgosInXQ5aISXl25l6U7TwDQo1Vj/jiyE0EBWgISEdekwCJSxxw6k0vCBykcPpuHhwUm3t+Gcfe1xtPDYnZpIiIVUmARqSMMw2DpjhP8btUeCoodBPlbmfVYLN1bNTa7NBGR61JgEakD8gtLeGXFHpJTTwJwT1QT3h3ZiSYNrCZXJiJyYxRYRGq5/aftJHyQwrfn8/H0sDC5bxt+c28rPLQEJCJuRIFFpJYyDINFX2cw/eN9FJU4CAnwZU58LJ1vCzS7NBERpymwiNRCuQXFvLx8N5/sOg1An7ZNeXtEJwLr+5hcmYhI1Th9ZajNmzczaNAgwsLCsFgsrFixotzrFovlmo8333yzwn0uXLjwmn0KCgqcHpBIXbfnZA6D5mzhk12n8fKwMOXBdrz3eGeFFRFxa07PsOTn5xMTE8MvfvELhg0bdtXrp0+fLvd8zZo1PPHEE9ds+2MBAQEcPHiw3DZfX10TQuRGGYbB37d9x/+s3k9RqYNmDf2YEx9LXPNGZpcmInLTnA4sAwcOZODAgRW+HhISUu75ypUr6dOnDy1btqx0vxaL5aq+InJjcq4U8+JHu1i7NwuAvtHBvPloRxrW06yKiNQONXoOy5kzZ1i9ejXvv//+ddvm5eURGRlJaWkpnTp14rXXXiM2NrbC9oWFhRQWFpY9t9vt1VKziLtJy8xm3KIUTly6grenhZcH3s4v7r4Ni0V/BSQitUeN3t3s/fffx9/fn6FDh1barl27dixcuJBVq1aRlJSEr68vd999N4cPH66wT2JiIjabrewRERFR3eWLuDTDMPjbF98y/M9bOXHpChGBfnz06x78smcLhRURqXUshmEYVe5ssZCcnMyQIUOu+Xq7du3o27cvc+bMcWq/DoeDuLg4evXqxezZs6/Z5lozLBEREeTk5BAQEODU1xNxN9mXi3hu6S4+238GgIHtQ3h9WEdsft4mVyYi4hy73Y7NZrvu53eNLQl98cUXHDx4kCVLljjd18PDg86dO1c6w2K1WrFadZVOqXt2fneJ8YtSOJVTgI+nB1Mfup3/6hapWRURqdVqLLC899573HnnncTExDjd1zAM0tLS6NChQw1UJuKeHA6Dv37xLW/+8yClDoPbGtdjbnwc7ZvZzC5NRKTGOR1Y8vLyOHLkSNnzY8eOkZaWRmBgIM2bNwe+n95ZunQpb7/99jX3MWbMGJo1a0ZiYiIA06dPp1u3bkRFRWG325k9ezZpaWnMmzevKmMSqXUu5hcx+cM0Nh48B8CgmDBmPNIef18tAYlI3eB0YNmxYwd9+vQpez558mQAHn/8cRYuXAjA4sWLMQyDUaNGXXMfGRkZeHj853zf7OxsfvWrX5GVlYXNZiM2NpbNmzfTpUsXZ8sTqXW+PnaRCUmpZNkLsHp5MO3hO3isc4SWgESkTrmpk25dyY2etCPiLhwOgz9tPMI76w/hMKBl0/rMi4/j9lB9f4tI7WH6SbciUnXncguZ/GEaXxw+D8DQ2Ga8NqQ99a06ZEWkbtJPPxEXs/XIeSYuSeNcbiG+3h68Nrg9w+/SdYZEpG5TYBFxEaUOg9n/Oszszw9jGNAmuAHz4uOICvY3uzQREdMpsIi4gLP2AiYuTmPbtxcAGHFXONMfbo+fj6fJlYmIuAYFFhGTfXH4HM8sSeN8XhH1fDz5n0fa80hsuNlliYi4FAUWEZOUlDr442eHmbfxCIYB7UL8mffzOFo1bWB2aSIiLkeBRcQEp3OuMDEpja+PXwQgvmtzfvdQNL7eWgISEbkWBRaRW2zDgbNM/jCNS5eLaWD1InFoBwbFhJldloiIS1NgEblFiksdvPXPg/xl87cAtG8WwNxRcdzWpL7JlYmIuD4FFpFb4GT2FcYvSiElIxuAsT1u4+UH22H10hKQiMiNUGARqWHr953huaXp5Fwpxt/Xizcf7ciA9qFmlyUi4lYUWERqSFGJg9fXHOB/vzwGQEy4jbnxcUQE1jO5MhER96PAIlIDMi9eZtyiFNJP5ADwRM8WvDigHT5eHtfpKSIi16LAIlLN1u45zfMf7SK3oASbnzdvDY+hb3Sw2WWJiLg1BRaRalJQXErip/t5f9t3AMQ1b8ic+DiaNfQzuTIREfenwCJSDY6fzydhUQp7T9kBeOreljzXry3enloCEhGpDgosIjfp4/RTvLx8N3mFJQTW9+HtETH0aRtkdlkiIrWKAotIFRUUl/L7T/axaHsGAF1uC2T2qFhCbL4mVyYiUvsosIhUwdFzeSR8kMKBrFwsFhjXpzUT74/CS0tAIiI1QoFFxEnJqSf4bfIeLheV0qSBD++O7MQ9UU3NLktEpFZTYBG5QVeKSvndyj0s3XkCgO4tGzPrsU4EBWgJSESkpimwiNyAQ2dySfgghcNn87BYYOL9UYy/LwpPD4vZpYmI1AkKLCKVMAyDpTtP8LuVeygodtDU38qsxzrRo1UTs0sTEalTFFhEKpBfWMLUFXtYnnoSgHuimvDuyE40aWA1uTIRkbpHgUXkGvaftpOwKIVvz+XjYYFn+7XlN/e2wkNLQCIiplBgEfkRwzBI+jqT6R/vpbDEQUiAL7NHxdKlRaDZpYmI1GkKLCL/lltQzJTkPXycfgqAPm2b8vaITgTW9zG5MhERUWARAfaczGHcohSOX7iMl4eF5/u35cl7WmoJSETERSiwSJ1mGAb/99V3/OGT/RSVOmjW0I/Zo2K5M7KR2aWJiMiPKLBInZVzpZiXlu1izZ4sAB64PZi3hnekYT0tAYmIuBoFFqmT0jOzGZeUQubFK3h7Wnhp4O388u7bsFi0BCQi4oqcvlPb5s2bGTRoEGFhYVgsFlasWFHu9bFjx2KxWMo9unXrdt39Llu2jOjoaKxWK9HR0SQnJztbmsh1GYbBe1uO8eift5J58QoRgX589OsePNGzhcKKiIgLczqw5OfnExMTw9y5cytsM2DAAE6fPl32+PTTTyvd57Zt2xg5ciSjR48mPT2d0aNHM2LECLZv3+5seSIVyr5cxJN/38lrn+yjuNRgYPsQPhl/DzERDc0uTURErsNiGIZR5c4WC8nJyQwZMqRs29ixY8nOzr5q5qUyI0eOxG63s2bNmrJtAwYMoFGjRiQlJd3QPux2OzabjZycHAICAm74a0vdsPO7S0xISuVk9hV8PD145aHbGd0tUrMqIiImu9HPb6dnWG7Exo0bCQoKok2bNjz55JOcPXu20vbbtm2jX79+5bb179+frVu3VtinsLAQu91e7iHyUw6HwV82HWXkX7ZxMvsKtzWux/KnezCmu85XERFxJ9V+0u3AgQMZPnw4kZGRHDt2jKlTp3Lfffexc+dOrNZr34MlKyuL4ODgctuCg4PJysqq8OskJiYyffr0aq1dapeL+UU8+2EaGw6eA2BQTBgzHmmPv6+3yZWJiIizqj2wjBw5suzf7du356677iIyMpLVq1czdOjQCvv99LddwzAq/Q345ZdfZvLkyWXP7XY7ERERN1G51CZfH7vIhKRUsuwFWL08eHXQHYzqEqFZFRERN1Xjf9YcGhpKZGQkhw8frrBNSEjIVbMpZ8+evWrW5cesVmuFMzZSdzkcBvM3HeWd9YcodRi0bFqfefFx3B6q85pERNxZjZzD8mMXLlwgMzOT0NDQCtt0796d9evXl9u2bt06evToUdPlSS1yPq+Qxxd8zZv/PEipw2BobDM+HtdTYUVEpBZweoYlLy+PI0eOlD0/duwYaWlpBAYGEhgYyLRp0xg2bBihoaEcP36cKVOm0KRJEx555JGyPmPGjKFZs2YkJiYCMHHiRHr16sXMmTMZPHgwK1eu5LPPPmPLli3VMESpC7YePc/ExWmcyy3E19uD3w9uz/A7w7UEJCJSSzgdWHbs2EGfPn3Knv9wHsnjjz/O/Pnz2b17N3//+9/Jzs4mNDSUPn36sGTJEvz9/cv6ZGRk4OHxn8mdHj16sHjxYl555RWmTp1Kq1atWLJkCV27dr2ZsUkdUOowmPP5YWb/6zAOA6KCGjDv53G0Cfa/fmcREXEbN3UdFlei67DUPWftBUxaksbWoxcAGHFXONMfbo+fj6fJlYmIyI260c9v3UtI3NIXh8/xzJI0zucVUc/Hkz8Mac/QuHCzyxIRkRqiwCJupaTUwR8/O8y8jUcwDGgX4s/c+DhaBzUwuzQREalBCiziNrJyCpiQlMrXxy8CEN+1Ob97KBpfby0BiYjUdgos4hY2HDzLsx+mczG/iAZWL2YM7cDDMWFmlyUiIreIAou4tOJSB2+tO8hfNn0LwB1hAcyLj+O2JvVNrkxERG4lBRZxWSezrzAhKZWd310C4PHukbz84O1aAhIRqYMUWMQlrd93hueWppNzpRh/Xy/eGNaRgR0qvlqyiIjUbgos4lKKShzMXHuA97YcAyAm3MacUXE0b1zP5MpERMRMCiziMjIvXmZcUirpmdkA/PLuFrw0sB0+XjV+yysREXFxCiziEtbuOc3zH+0it6AEm583bw2PoW90xXfrFhGRukWBRUxVWFLKjNX7eX/bdwDENW/I7FGxhDfSEpCIiPyHAouY5vj5fMYlpbDnpB2Ap+5tyXP92uLtqSUgEREpT4FFTPHJrlO8tGw3eYUlNKrnzTsjOtGnXZDZZYmIiItSYJFbqqC4lN9/so9F2zMA6HxbI2aPiiXU5mdyZSIi4soUWOSWOXouj4QPUjiQlYvFAgm9WzPpgSi8tAQkIiLXocAit0Ry6gl+m7yHy0WlNK7vwx8f68Q9UU3NLktERNyEAovUqCtFpby6ag8f7jgBQPeWjZn1WCeCAnxNrkxERNyJAovUmMNncklYlMKhM3lYLDDhvigm3B+Fp4fF7NJERMTNKLBIjVi6I5OpK/dQUOygqb+VWSM70aN1E7PLEhERN6XAItUqv7CEqSv3sDzlJAD3RDXhnRGdaOpvNbkyERFxZwosUm0OZNlJ+CCFo+fy8bDAs/3a8pt7W+GhJSAREblJCixy0wzDYPE3mUxbtZfCEgchAb7MHhVLlxaBZpcmIiK1hAKL3JTcgmKmJO/h4/RTAPRu25R3RnQisL6PyZWJiEhtosAiVbbnZA7jFqVw/MJlPD0svNC/LU/e01JLQCIiUu0UWMRphmHwj6++47VP9lNU6iDM5suc+DjujGxkdmkiIlJLKbCIU+wFxby0bBef7s4C4IHbg3lreEca1tMSkIiI1BwFFrlh6ZnZjEtKIfPiFbw9Lbw4oB1P9GyBxaIlIBERqVkKLHJdhmGw4MvjJK7ZT3GpQXgjP+bGx9EpoqHZpYmISB2hwCKVyr5cxPMf7WL9vjMADLgjhJmPdsTm521yZSIiUpcosEiFUjIuMX5RKiezr+Dj6cErD93O6G6RWgISEZFbToFFruJwGPxty7e8sfYgJQ6DyMb1mBcfR/tmNrNLExGROsrD2Q6bN29m0KBBhIWFYbFYWLFiRdlrxcXFvPjii3To0IH69esTFhbGmDFjOHXqVKX7XLhwIRaL5apHQUGB0wOSm3Mxv4j//vsOZnx6gBKHwUMdQ/lkfE+FFRERMZXTgSU/P5+YmBjmzp171WuXL18mJSWFqVOnkpKSwvLlyzl06BAPP/zwdfcbEBDA6dOnyz18fX2dLU9uwjfHL/Kz2V/w+YGz+Hh5MOORDswZFYu/r85XERERczm9JDRw4EAGDhx4zddsNhvr168vt23OnDl06dKFjIwMmjdvXuF+LRYLISEhzpYj1cDhMJi/6SjvrD9EqcOgZZP6zPt5HLeHBphdmoiICHALzmHJycnBYrHQsGHDStvl5eURGRlJaWkpnTp14rXXXiM2NrbC9oWFhRQWFpY9t9vt1VVynXI+r5BnlqTxxeHzADwS24w/DGlPfatObxIREdfh9JKQMwoKCnjppZeIj48nIKDi39bbtWvHwoULWbVqFUlJSfj6+nL33Xdz+PDhCvskJiZis9nKHhERETUxhFpt29ELPDjrC744fB5fbw/eGNaRd0bEKKyIiIjLsRiGYVS5s8VCcnIyQ4YMueq14uJihg8fTkZGBhs3bqw0sPyUw+EgLi6OXr16MXv27Gu2udYMS0REBDk5OU59rbqo1GEw9/MjzPrXIRwGRAU1YN7P42gT7G92aSIiUsfY7XZsNtt1P79r5Ffp4uJiRowYwbFjx/j888+dDhAeHh507ty50hkWq9WK1Wq92VLrnLO5BUxanMbWoxcAGH5nONMH30E9H82qiIiI66r2T6kfwsrhw4fZsGEDjRs3dnofhmGQlpZGhw4dqru8Om3L4fNMWpLK+bwi6vl48och7RkaF252WSIiItfldGDJy8vjyJEjZc+PHTtGWloagYGBhIWF8eijj5KSksInn3xCaWkpWVnf39U3MDAQH5/v7+g7ZswYmjVrRmJiIgDTp0+nW7duREVFYbfbmT17NmlpacybN686xljnlZQ6mPWvw8zdcATDgHYh/syNj6N1UAOzSxMREbkhTgeWHTt20KdPn7LnkydPBuDxxx9n2rRprFq1CoBOnTqV67dhwwZ69+4NQEZGBh4e/znfNzs7m1/96ldkZWVhs9mIjY1l8+bNdOnSxdny5CeycgqYsDiVr49dBGBUl+a8OigaX29PkysTERG5cTd10q0rudGTduqSjQfPMvnDdC7mF1Hfx5PEYR15OCbM7LJERETKmHrSrZiruNTB2+sO8edNRwG4IyyAufFxtGhS3+TKREREqkaBpZY5lX2F8Ump7PzuEgBjukcy5cHbtQQkIiJuTYGlFvls3xme+yid7MvF+Fu9mPloRx7sEGp2WSIiIjdNgaUWKCpx8MbaA/xtyzEAOobbmDsqjuaN65lcmYiISPVQYHFzmRcvMy4plfTMbAB+eXcLXhrYDh+vGr3rgoiIyC2lwOLG1u7J4vmP0sktKCHA14u3hsfQ7w7d8VpERGofBRY3VFhSSuKnB1i49TgAsc0bMmdULOGNtAQkIiK1kwKLm/nuQj7jFqWy+2QOAE/1aslz/dvi7aklIBERqb0UWNzIJ7tO8dKy3eQVltConjdvj4jhvnbBZpclIiJS4xRY3EBBcSmvfbKPD7ZnAND5tkbMHhVLqM3P5MpERERuDQUWF/ftuTwSFqWy/7QdiwWe7t2KZx5og5eWgEREpA5RYHFhK1JPMiV5N5eLSmlc34d3R3aiV5umZpclIiJyyymwuKArRaVMW7WXJTsyAejWMpBZj8USHOBrcmUiIiLmUGBxMYfP5JKwKIVDZ/KwWGDCfVFMuD8KTw+L2aWJiIiYRoHFhSzdkcnvVu7lSnEpTf2tzBrZiR6tm5hdloiIiOkUWFxAfmEJU1fuYXnKSQB6tm7CuyM70dTfanJlIiIirkGBxWQHsuwkfJDC0XP5eFhgct82PN27NR5aAhIRESmjwGISwzBY8k0mr67aS2GJg+AAK7Mfi6Vry8ZmlyYiIuJyFFhMkFdYwpTlu1mVfgqAe9s05Z0RMTRuoCUgERGRa1FgucX2nsph3KJUjp3Px9PDwvP92/Kre1pqCUhERKQSCiy3iGEY/OOr73ht9X6KShyE2XyZEx/LnZGBZpcmIiLi8hRYbgF7QTEvLdvFp7uzAHjg9iDefDSGRvV9TK5MRETEPSiw1LBdJ7IZtyiVjIuX8fa08OKAdjzRswUWi5aAREREbpQCSw0xDIMFXx4ncc1+iksNwhv5MTc+jk4RDc0uTURExO0osNSAnMvFPP9ROuv2nQFgwB0hzHy0IzY/b5MrExERcU8KLNUsNeMS4xalcjL7Cj6eHvz2Z7czpnukloBERERuggJLNXE4DN7bcoyZaw9Q4jCIbFyPuaPi6BBuM7s0ERERt6fAUg0u5Rfx7NJ0Pj9wFoCfdQzl9aEd8PfVEpCIiEh1UGC5STuOX2R8Uiqncwrw8fLg1UHRxHdpriUgERGRaqTAUkUOh8GfNx/l7XWHKHUYtGxSn7nxcUSHBZhdmoiISK2jwFIF5/MKmfxhOpsPnQNgSKcw/vBIBxpY9d8pIiJSEzyc7bB582YGDRpEWFgYFouFFStWlHvdMAymTZtGWFgYfn5+9O7dm7179153v8uWLSM6Ohqr1Up0dDTJycnOlnZLfPXtBR6c9QWbD53D19uDN4Z15N2RnRRWREREapDTgSU/P5+YmBjmzp17zdffeOMN3nnnHebOncs333xDSEgIffv2JTc3t8J9btu2jZEjRzJ69GjS09MZPXo0I0aMYPv27c6WV2NKHQazPjtM/P/7irO5hbQOasCqcT0Z0TlC56uIiIjUMIthGEaVO1ssJCcnM2TIEOD72ZWwsDAmTZrEiy++CEBhYSHBwcHMnDmTp5566pr7GTlyJHa7nTVr1pRtGzBgAI0aNSIpKemGarHb7dhsNnJycggIqN7zSM7mFvDMkjS+PHIBgOF3hjN98B3U89GsioiIyM240c9vp2dYKnPs2DGysrLo169f2Tar1cq9997L1q1bK+y3bdu2cn0A+vfvX2mfwsJC7HZ7uUdN+PLIeR6ctYUvj1zAz9uTd0bE8ObwGIUVERGRW6haA0tW1vd3Iw4ODi63PTg4uOy1ivo52ycxMRGbzVb2iIiIuInKr+1KUSkTF6dxPq+QdiH+fDy+J0Pjwqv964iIiEjlqjWw/OCn53QYhnHd8zyc7fPyyy+Tk5NT9sjMzKx6wRXw8/Hk7RExjOrSnBUJd9M6qEG1fw0RERG5vmpd1wgJCQG+nzEJDQ0t23727NmrZlB+2u+nsynX62O1WrFarTdZ8fXd26Yp97ZpWuNfR0RERCpWrTMsLVq0ICQkhPXr15dtKyoqYtOmTfTo0aPCft27dy/XB2DdunWV9hEREZG6w+kZlry8PI4cOVL2/NixY6SlpREYGEjz5s2ZNGkSM2bMICoqiqioKGbMmEG9evWIj48v6zNmzBiaNWtGYmIiABMnTqRXr17MnDmTwYMHs3LlSj777DO2bNlSDUMUERERd+d0YNmxYwd9+vQpez558mQAHn/8cRYuXMgLL7zAlStXePrpp7l06RJdu3Zl3bp1+Pv7l/XJyMjAw+M/kzs9evRg8eLFvPLKK0ydOpVWrVqxZMkSunbtejNjExERkVripq7D4kpq8josIiIiUjNMuQ6LiIiISE1QYBERERGXp8AiIiIiLk+BRURERFyeAouIiIi4PAUWERERcXkKLCIiIuLyFFhERETE5SmwiIiIiMur1rs1m+mHC/ba7XaTKxEREZEb9cPn9vUuvF9rAktubi4AERERJlciIiIizsrNzcVms1X4eq25l5DD4eDUqVP4+/tjsViqbb92u52IiAgyMzNr7T2KavsYNT73V9vHqPG5v9o+xpocn2EY5ObmEhYWVu7GyD9Va2ZYPDw8CA8Pr7H9BwQE1Mpvwh+r7WPU+NxfbR+jxuf+avsYa2p8lc2s/EAn3YqIiIjLU2ARERERl6fAch1Wq5VXX30Vq9Vqdik1praPUeNzf7V9jBqf+6vtY3SF8dWak25FRESk9tIMi4iIiLg8BRYRERFxeQosIiIi4vIUWERERMTl1anAsnnzZgYNGkRYWBgWi4UVK1Zct8+mTZu488478fX1pWXLlvz5z3++qs2yZcuIjo7GarUSHR1NcnJyDVR/Y5wd4/Lly+nbty9NmzYlICCA7t27889//rNcm4ULF2KxWK56FBQU1OBIrs3Z8W3cuPGatR84cKBcO1d5D50d39ixY685vjvuuKOsjSu9f4mJiXTu3Bl/f3+CgoIYMmQIBw8evG4/dzoOqzJGdzoOqzI+dzoOqzI+dzsO58+fT8eOHcsuAte9e3fWrFlTaR9XOAbrVGDJz88nJiaGuXPn3lD7Y8eO8eCDD3LPPfeQmprKlClTmDBhAsuWLStrs23bNkaOHMno0aNJT09n9OjRjBgxgu3bt9fUMCrl7Bg3b95M3759+fTTT9m5cyd9+vRh0KBBpKamlmsXEBDA6dOnyz18fX1rYgiVcnZ8Pzh48GC52qOiospec6X30NnxzZo1q9y4MjMzCQwMZPjw4eXaucr7t2nTJhISEvjqq69Yv349JSUl9OvXj/z8/Ar7uNtxWJUxutNxWJXx/cAdjsOqjM/djsPw8HBef/11duzYwY4dO7jvvvsYPHgwe/fuvWZ7lzkGjToKMJKTkytt88ILLxjt2rUrt+2pp54yunXrVvZ8xIgRxoABA8q16d+/v/HYY49VW61VdSNjvJbo6Ghj+vTpZc8XLFhg2Gy26iusmtzI+DZs2GAAxqVLlyps46rvYVXev+TkZMNisRjHjx8v2+aq759hGMbZs2cNwNi0aVOFbdz9OLyRMV6LuxyHNzI+dz4Oq/L+udtxaBiG0ahRI+Nvf/vbNV9zlWOwTs2wOGvbtm3069ev3Lb+/fuzY8cOiouLK22zdevWW1ZndXI4HOTm5hIYGFhue15eHpGRkYSHh/PQQw9d9Zufq4uNjSU0NJT777+fDRs2lHutNr2H7733Hg888ACRkZHltrvq+5eTkwNw1ffbj7n7cXgjY/wpdzoOnRmfOx6HVXn/3Ok4LC0tZfHixeTn59O9e/drtnGVY1CBpRJZWVkEBweX2xYcHExJSQnnz5+vtE1WVtYtq7M6vf322+Tn5zNixIiybe3atWPhwoWsWrWKpKQkfH19ufvuuzl8+LCJld6Y0NBQ/vrXv7Js2TKWL19O27Ztuf/++9m8eXNZm9ryHp4+fZo1a9bw3//93+W2u+r7ZxgGkydPpmfPnrRv377Cdu58HN7oGH/KXY7DGx2fux6HVXn/3OU43L17Nw0aNMBqtfLrX/+a5ORkoqOjr9nWVY7BWnO35ppisVjKPTf+fWHgH2+/VpufbnMHSUlJTJs2jZUrVxIUFFS2vVu3bnTr1q3s+d13301cXBxz5sxh9uzZZpR6w9q2bUvbtm3Lnnfv3p3MzEzeeustevXqVba9NryHCxcupGHDhgwZMqTcdld9/8aNG8euXbvYsmXLddu663HozBh/4E7H4Y2Oz12Pw6q8f+5yHLZt25a0tDSys7NZtmwZjz/+OJs2baowtLjCMagZlkqEhIRclQ7Pnj2Ll5cXjRs3rrTNT5Omq1uyZAlPPPEEH374IQ888EClbT08POjcubPpv6FXVbdu3crVXhveQ8Mw+N///V9Gjx6Nj49PpW1d4f0bP348q1atYsOGDYSHh1fa1l2PQ2fG+AN3Og6rMr4fc/XjsCrjc6fj0MfHh9atW3PXXXeRmJhITEwMs2bNumZbVzkGFVgq0b17d9avX19u27p167jrrrvw9vautE2PHj1uWZ03KykpibFjx7Jo0SJ+9rOfXbe9YRikpaURGhp6C6qrfqmpqeVqrw3v4aZNmzhy5AhPPPHEddua+f4ZhsG4ceNYvnw5n3/+OS1atLhuH3c7DqsyRnCf47Cq4/spVz0Ob2Z87nIcXothGBQWFl7zNZc5Bqvt9F03kJuba6SmphqpqakGYLzzzjtGamqq8d133xmGYRgvvfSSMXr06LL23377rVGvXj3jmWeeMfbt22e89957hre3t/HRRx+Vtfnyyy8NT09P4/XXXzf2799vvP7664aXl5fx1Vdf3fLxGYbzY1y0aJHh5eVlzJs3zzh9+nTZIzs7u6zNtGnTjLVr1xpHjx41UlNTjV/84heGl5eXsX37dpcf37vvvmskJycbhw4dMvbs2WO89NJLBmAsW7asrI0rvYfOju8H//Vf/2V07dr1mvt0pffvN7/5jWGz2YyNGzeW+367fPlyWRt3Pw6rMkZ3Og6rMj53Og6rMr4fuMtx+PLLLxubN282jh07ZuzatcuYMmWK4eHhYaxbt84wDNc9ButUYPnhT+t++nj88ccNwzCMxx9/3Lj33nvL9dm4caMRGxtr+Pj4GLfddpsxf/78q/a7dOlSo23btoa3t7fRrl27cgfhrebsGO+9995K2xuGYUyaNMlo3ry54ePjYzRt2tTo16+fsXXr1ls7sH9zdnwzZ840WrVqZfj6+hqNGjUyevbsaaxevfqq/brKe1iV79Hs7GzDz8/P+Otf/3rNfbrS+3etsQHGggULytq4+3FYlTG603FYlfG503FY1e9RdzoOf/nLXxqRkZFltdx///1lYcUwXPcYtBjGv8+cEREREXFROodFREREXJ4Ci4iIiLg8BRYRERFxeQosIiIi4vIUWERERMTlKbCIiIiIy1NgEREREZenwCIiIiIuT4FFREREXJ4Ci4iIiLg8BRYRERFxeQosIiIi4vL+PyIejQhsOBomAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([1,2,3],[10,20,30])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
